gravityp 0.1.0__tar.gz

gravityp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Álvaro Salazar Cuadros
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gravityp-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: gravityp
+Version: 0.1.0
+Summary: GRAVITYp is a Python library to study the optical appearance of spherically symmetric compact objects in General Relativity. It stands for Geodesic RAys and Visualization of IntensiTY profiles.
+Author-email: Alvaro Salazar-Cuadros <a.salazar@uva.es>, Diego Saez-Chillon Gomez <diego.saez@uva.es>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/alvaroslzar/GRAVITYp
+Project-URL: Issues, https://github.com/alvaroslzar/GRAVITYp/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.11
+Requires-Dist: matplotlib>=3.8
+Provides-Extra: notebooks
+Requires-Dist: jupyter>=1.0; extra == "notebooks"
+Requires-Dist: ipykernel>=6.0; extra == "notebooks"
+Dynamic: license-file
+
+# GRAVITYp
+
+**GRAVITYp** is a Python package for studying the optical appearance of spherically symmetric compact objects in General Relativity.
+It stands for **G**eodesic **RA**ys and **V**isualization of **I**ntensi**TY** **p**rofiles. 
+
+## About the project
+
+This is the Python implementation of **GRAVITYp**, which is originally a numerical code in Wolfram language developed by G.J. Olmo, D. Rubiera García, J.L. Rosa, D. Sáez-Chillón and collaborators [arXiv:2307.06778v2](https://arxiv.org/abs/2307.06778v2).
+It was developed to study the optical appearance or *shadow* cast by black holes, wormholes and different kinds of exotic compact objects, inspired by the work of S.E. Gralla et al. [arXiv:1906.00873](https://arxiv.org/abs/1906.00873).
+
+Then, Á. Salazar Cuadros preferred to work on Python seeking faster execution times for simulations and a language better suited for Version Control Systems (VCS), and that's how the Python implementation was born.
+The goal of this open source version is to provide open access to anyone interested in using the package or learning how simulated black hole shadow images are generated.
+
+## Installation
+
+You can clone `GRAVITYp` locally in editable mode for research and development:
+
+```bash
+git clone git@github.com:alvaroslzar/GRAVITYp.git       # SSH
+git clone https://github.com/alvaroslzar/GRAVITYp.git   # HTTPS
+```
+
+Then, install it in your virtual environment
+
+```bash
+cd GRAVITYp
+pip install -e .
+```
+
+## Usage
+
+### Quick example
+
+```python
+import numpy as np
+from gravityp import make_geodesics_plot
+
+def g_rr(r: float, dummy) -> float:
+    """Radial function g^{rr} of the Schwarzschild metric in units of M=1"""
+    return 1 - 2./r
+
+def g_thth(r: float, dummy) -> float:
+    """Areal radius squared g^{theta theta} of the Schwarzschild in units of M=1"""
+    return r**2
+
+# Dictionary codifying Schwarzschild metric and required params
+Schwarzschild_kwargs = {
+    'r_phs': [3.,],         # Photon sphere at r=3M
+    'inner_edge': 2.,       # Inner edge of disk at horizon r=2M
+    'radial_fun': g_rr,     # Above defined radial function
+    'radial_params': None,  # g_rr has no additional params
+    'areal': g_thth,        # Above defined areal radius squared
+    'areal_params': None,   # g_thth has no additional params
+}
+
+# Array of impact parameters from 0M to 10M
+impact_parameters = np.arange(0,10,0.2)
+make_geodesics_plot(impact_parameters, figsize=(4,4), **Schwarzschild_kwargs)
+```
+
+The output image looks like this:
+
+![ray-tracing](docs/images/README_ray_tracing.png)
+
+For a more detailed explanation, check the Jupyter notebooks in the [Examples](Examples/) folder for details.
+
+### Intensity profiles and black hole shadows
+
+The primary use is to obtain the observed intensity profile $I_\mathrm{ob}(b)$ as a function of the impact parameter $b$ given some predefined emission profile $I_\mathrm{em}(r)$.
+The emitted light is due to the matter in the accretion disk, which is assumed to be both geometrically and optically thin.
+Moreover, the orientation is assumed to be face-on with respect to the accretion disk, so the optical appearance has have rotational symmetry.
+
+In the following images, the emission profile of the accretion disk has been chosen to peak at the event horizon $r=2M$, and the optical appearance corresponds to a Schwarzschild black hole.ç
+The code properly reproduces the predicted light rings up to two intersections with the accretion disk, as well as the central brightness depression or *shadow* characteristic of compact objects such as black holes.
+
+![emitted](docs/images/README_emitted.png)
+![observed](docs/images/README_observed.png)
+![shadow](docs/images/README_shadow.png)
+
+### Further references
+
+Watch Prof. D. Rubiera García's [talk](https://www.youtube.com/live/q0a4RXdxk4o?si=njtj2yOmCwim25ix) for an overview of the main concepts involved in the ray-tracing method and analysis of intensity profiles.
+
+For an introductory discussion of the inner workings of the Wolfram Mathematica code, watch Prof. G.J. Olmo's [tutorial](https://www.youtube.com/live/f5-s2gVd5xE?si=xCtJxFQikmkLehdU); for a more user-friendly application, watch Dr. J.L. Rosa's [talk](https://www.youtube.com/live/9k8qMq9V814?si=MtXYMg0exd_6_37t).
+
+Finally, for a more advanced topic regarding compact objects, watch Prof. D. Sáez-Chillón's [contribution](https://www.youtube.com/watch?v=8pR8kE_ABzQ).
+
+## Citation
+
+The use of **GRAVITYp** in scientific publications must be properly acknowledged.
+Please cite the following:
+
+**BibTeX**
+```
+@article{Nojiri:2026tjn,
+    author = "Nojiri, Shin'ichi and Odintsov, Sergei D. and S{\'a}ez-Chill{\'o}n G{\'o}mez, Diego and Cuadros, {\'A}lvaro Salazar",
+    title = "{Horizon singularity, energy conditions and shadows in time-dependent and spherically symmetric spacetime}",
+    eprint = "2608.15740",
+    archivePrefix = "arXiv",
+    primaryClass = "gr-qc",
+    reportNumber = "KEK-TH-2861, KEK-Cosmo-0429",
+    month = "8",
+    year = "2026"
+}
+```
+
+## Publications using GRAVITYp
+
+Let us know if you use **GRAVITYp** in your publication, and we will add it to the [list of publications](/docs/PUBLICATIONS.md)!
+
+## Author
+
+The author and mantainer of the Python code is Álvaro Salazar Cuadros.
+
+## License
+
+The software is licensed under the [MIT license](LICENSE).

gravityp-0.1.0/README.md

@@ -0,0 +1,117 @@
+# GRAVITYp
+
+**GRAVITYp** is a Python package for studying the optical appearance of spherically symmetric compact objects in General Relativity.
+It stands for **G**eodesic **RA**ys and **V**isualization of **I**ntensi**TY** **p**rofiles. 
+
+## About the project
+
+This is the Python implementation of **GRAVITYp**, which is originally a numerical code in Wolfram language developed by G.J. Olmo, D. Rubiera García, J.L. Rosa, D. Sáez-Chillón and collaborators [arXiv:2307.06778v2](https://arxiv.org/abs/2307.06778v2).
+It was developed to study the optical appearance or *shadow* cast by black holes, wormholes and different kinds of exotic compact objects, inspired by the work of S.E. Gralla et al. [arXiv:1906.00873](https://arxiv.org/abs/1906.00873).
+
+Then, Á. Salazar Cuadros preferred to work on Python seeking faster execution times for simulations and a language better suited for Version Control Systems (VCS), and that's how the Python implementation was born.
+The goal of this open source version is to provide open access to anyone interested in using the package or learning how simulated black hole shadow images are generated.
+
+## Installation
+
+You can clone `GRAVITYp` locally in editable mode for research and development:
+
+```bash
+git clone git@github.com:alvaroslzar/GRAVITYp.git       # SSH
+git clone https://github.com/alvaroslzar/GRAVITYp.git   # HTTPS
+```
+
+Then, install it in your virtual environment
+
+```bash
+cd GRAVITYp
+pip install -e .
+```
+
+## Usage
+
+### Quick example
+
+```python
+import numpy as np
+from gravityp import make_geodesics_plot
+
+def g_rr(r: float, dummy) -> float:
+    """Radial function g^{rr} of the Schwarzschild metric in units of M=1"""
+    return 1 - 2./r
+
+def g_thth(r: float, dummy) -> float:
+    """Areal radius squared g^{theta theta} of the Schwarzschild in units of M=1"""
+    return r**2
+
+# Dictionary codifying Schwarzschild metric and required params
+Schwarzschild_kwargs = {
+    'r_phs': [3.,],         # Photon sphere at r=3M
+    'inner_edge': 2.,       # Inner edge of disk at horizon r=2M
+    'radial_fun': g_rr,     # Above defined radial function
+    'radial_params': None,  # g_rr has no additional params
+    'areal': g_thth,        # Above defined areal radius squared
+    'areal_params': None,   # g_thth has no additional params
+}
+
+# Array of impact parameters from 0M to 10M
+impact_parameters = np.arange(0,10,0.2)
+make_geodesics_plot(impact_parameters, figsize=(4,4), **Schwarzschild_kwargs)
+```
+
+The output image looks like this:
+
+![ray-tracing](docs/images/README_ray_tracing.png)
+
+For a more detailed explanation, check the Jupyter notebooks in the [Examples](Examples/) folder for details.
+
+### Intensity profiles and black hole shadows
+
+The primary use is to obtain the observed intensity profile $I_\mathrm{ob}(b)$ as a function of the impact parameter $b$ given some predefined emission profile $I_\mathrm{em}(r)$.
+The emitted light is due to the matter in the accretion disk, which is assumed to be both geometrically and optically thin.
+Moreover, the orientation is assumed to be face-on with respect to the accretion disk, so the optical appearance has have rotational symmetry.
+
+In the following images, the emission profile of the accretion disk has been chosen to peak at the event horizon $r=2M$, and the optical appearance corresponds to a Schwarzschild black hole.ç
+The code properly reproduces the predicted light rings up to two intersections with the accretion disk, as well as the central brightness depression or *shadow* characteristic of compact objects such as black holes.
+
+![emitted](docs/images/README_emitted.png)
+![observed](docs/images/README_observed.png)
+![shadow](docs/images/README_shadow.png)
+
+### Further references
+
+Watch Prof. D. Rubiera García's [talk](https://www.youtube.com/live/q0a4RXdxk4o?si=njtj2yOmCwim25ix) for an overview of the main concepts involved in the ray-tracing method and analysis of intensity profiles.
+
+For an introductory discussion of the inner workings of the Wolfram Mathematica code, watch Prof. G.J. Olmo's [tutorial](https://www.youtube.com/live/f5-s2gVd5xE?si=xCtJxFQikmkLehdU); for a more user-friendly application, watch Dr. J.L. Rosa's [talk](https://www.youtube.com/live/9k8qMq9V814?si=MtXYMg0exd_6_37t).
+
+Finally, for a more advanced topic regarding compact objects, watch Prof. D. Sáez-Chillón's [contribution](https://www.youtube.com/watch?v=8pR8kE_ABzQ).
+
+## Citation
+
+The use of **GRAVITYp** in scientific publications must be properly acknowledged.
+Please cite the following:
+
+**BibTeX**
+```
+@article{Nojiri:2026tjn,
+    author = "Nojiri, Shin'ichi and Odintsov, Sergei D. and S{\'a}ez-Chill{\'o}n G{\'o}mez, Diego and Cuadros, {\'A}lvaro Salazar",
+    title = "{Horizon singularity, energy conditions and shadows in time-dependent and spherically symmetric spacetime}",
+    eprint = "2608.15740",
+    archivePrefix = "arXiv",
+    primaryClass = "gr-qc",
+    reportNumber = "KEK-TH-2861, KEK-Cosmo-0429",
+    month = "8",
+    year = "2026"
+}
+```
+
+## Publications using GRAVITYp
+
+Let us know if you use **GRAVITYp** in your publication, and we will add it to the [list of publications](/docs/PUBLICATIONS.md)!
+
+## Author
+
+The author and mantainer of the Python code is Álvaro Salazar Cuadros.
+
+## License
+
+The software is licensed under the [MIT license](LICENSE).

gravityp-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gravityp"
+version = "0.1.0"
+authors = [
+  { name="Alvaro Salazar-Cuadros", email="a.salazar@uva.es" },
+  { name="Diego Saez-Chillon Gomez", email="diego.saez@uva.es" },
+
+]
+description = "GRAVITYp is a Python library to study the optical appearance of spherically symmetric compact objects in General Relativity. It stands for Geodesic RAys and Visualization of IntensiTY profiles."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "numpy>=1.26",
+    "scipy>=1.11",
+    "matplotlib>=3.8",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.optional-dependencies]
+notebooks = [
+    "jupyter>=1.0",
+    "ipykernel>=6.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/alvaroslzar/GRAVITYp"
+Issues = "https://github.com/alvaroslzar/GRAVITYp/issues"

gravityp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gravityp-0.1.0/src/gravityp/__init__.py

@@ -0,0 +1,46 @@
+"""
+GRAVITYp: Python package to study the optical appearance of spherically symmetric
+compact objects in General Relativity.
+
+Source:    https://github.com/alvaroslzar/GRAVITYp
+"""
+
+from .utils import *
+from .geodesic_integration import *
+from .ray_tracing import *
+from .rings import *
+from .transfer_functions import *
+from .emission_models import *
+from .shadows import *
+from .plots import *
+
+import email.utils
+from importlib.metadata import metadata, PackageNotFoundError
+
+__name__ = "gravityp"
+
+try:
+    _meta = metadata(__name__)
+    __version__ = _meta.get("Version", "0.1.0")
+
+    # setuptools packs pyproject.toml authors into the 'Author-email' header
+    _author_email_header = _meta.get("Author-email")
+
+    if _author_email_header:
+        # Parse header into [("Name", "email@domain.com"), ...]
+        _parsed_contacts = email.utils.getaddresses([_author_email_header])
+        
+        _names = [name for name, _ in _parsed_contacts if name]
+        _emails = [addr for _, addr in _parsed_contacts if addr]
+        
+        # Format as strings so help(gravityp) displays them cleanly
+        __author__ = ", ".join(_names) if _names else _meta.get("Author")
+        __email__ = ", ".join(_emails) if _emails else None
+    else:
+        __author__ = _meta.get("Author")
+        __email__ = None
+
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+    __author__ = "Gonzalo J. Olmo, Diego Rubiera-Garcia, João Luís Rosa, Diego Sáez-Chillón Gómez, Álvaro Salazar-Cuadros"
+    __email__ = None

gravityp-0.1.0/src/gravityp/emission_models.py

@@ -0,0 +1,45 @@
+"""This module contains some predefined emission profiles
+"""
+
+import numpy as np
+import scipy.optimize as optimize
+
+
+__all__ = [
+    "intensity_at_ISCO",
+    "intensity_at_photon_ring",
+    "intensity_at_inner_edge",
+    "standard_Unbound",
+    "normalized_Standard_Unbound",
+    "exponential",
+    "uniform"
+]
+
+
+def intensity_at_ISCO(r, r_ISCO):
+    func = lambda x: (1./(x-(r_ISCO-1))**2) / (1./(r_ISCO-(r_ISCO-1))**2)
+    return np.piecewise(r, [r>=r_ISCO,r<r_ISCO] , [func,0] )
+
+def intensity_at_photon_ring(r, r_ph):
+    func = lambda x: (1./(x-(r_ph-1))**3) / (1./(r_ph-(r_ph-1))**3)
+    return np.piecewise(r, [r>=r_ph,r<r_ph] , [func,0] )
+
+def intensity_at_inner_edge(r, inner_edge):
+    func = lambda x: ( np.pi/2-np.arctan(x-5) ) / ( np.pi/2-np.arctan(inner_edge-5) )
+    return np.piecewise(r, [r>=inner_edge,r<inner_edge] , [func,0] )
+
+def standard_Unbound(r, mu: float=8., sigma: float=2., gamma: float=2.):
+    return ( np.exp(-0.5*(gamma+np.arcsinh((r-mu)/sigma))**2) / 
+            np.sqrt((r-mu)**2+sigma**2) )
+
+def normalized_Standard_Unbound(r, mu: float=8., sigma: float=2., gamma: float=2.):
+    # FIXME: for some values of params, it doesn't find the minimum
+    neg_fun = lambda r: -standard_Unbound(r, mu, sigma, gamma)
+    minimum = optimize.minimize(neg_fun, 0).fun
+    return neg_fun(r)/minimum
+
+def exponential(r):
+    return np.exp(-r)
+
+def uniform(r):
+    return np.ones(shape=r.shape)

gravityp-0.1.0/src/gravityp/geodesic_integration.py

@@ -0,0 +1,192 @@
+"""This module contains all the functions needed for the geodesic integration
+routine
+"""
+
+import numpy as np
+import scipy.integrate as integrate
+import scipy.optimize as optimize
+from bisect import bisect_right
+
+from .utils import to_tuple
+
+
+__all__ = [
+    "potential",
+    "get_increasing_maxima",
+    "find_interval",
+    "find_rmin",
+    "geodesic_in",
+    "geodesic_out",
+    "compute_outgoing",
+    "compute_geodesic",
+]
+
+DEFAULT_NPOINTS = 100000  # ODE integration resolution
+DEFAULT_R0 = 1000.0  # Asymptotic boundary for initial conditions
+MINIMUM_R = 1e-6 # Minimum value of r for integration
+
+
+def potential(r, radial_fun, radial_params, areal, areal_params):
+    """ 
+    Effective potential of a spherically symmetric metric of the form:
+
+    ds^2 = - radial_fun(r; radial_params)dt^2 + 1/radial_fun(r; radial_params)dr^2 + areal(r; areal_params)dOmega^2
+
+    Parameters:
+        r (float): radial coordinate of the metric
+        radial_fun (callable): -gtt metric function. Its first argument must be r
+        radial_params (float | tuple): additional parameters for radial_fun
+        areal (callable): areal radius squared.  Its first argument must be r
+        areal_params (float | tuple): additional parameters for areal
+    """
+    return radial_fun(r,*to_tuple(radial_params)) / areal(r,*to_tuple(areal_params))
+    
+def get_increasing_maxima(r_phs, potential):
+    """Returns increasing local maxima of the potential with their photon sphere values"""
+    if len(r_phs) >= 1: # There has to be at least 1 local maximum
+        r_phs = np.array(r_phs)
+        r_phs = np.sort(r_phs)[::-1] # descending order of 
+        photon_sph = r_phs[0].reshape(1,)
+        local_maxima = potential(photon_sph)
+        for r_ph in r_phs:
+            maximum = potential(r_ph)
+            if maximum > local_maxima.max(): # We take increasing local maxima
+                local_maxima = np.append(local_maxima, maximum)
+                photon_sph = np.append(photon_sph, r_ph)
+        return photon_sph[::-1], local_maxima[::-1] # Swap to ascending order of photon_spheres
+    else:
+        return np.array([]), np.array([])
+
+def find_interval(inverse_b2, photon_sph, local_maxima, lower_bound=1e-4, upper_bound=100):
+    """Returns the bounds (r1,r2) where the rmin is found for a given 1/b^2"""
+    # NOTE: photon_sph and local_maxima have to be ordered by get_increasing_maxima
+    if len(photon_sph)==0 and len(local_maxima)==0: # Case 1: there is no local maximum
+        return (lower_bound, upper_bound)
+    if inverse_b2 >= local_maxima[0]: # Case 2: 1/b^2 higher than all local maxima
+        return (lower_bound, photon_sph[0])
+    if inverse_b2 <= local_maxima[-1]: # Case 3: 1/b^2 lower than all local maxima
+        return (photon_sph[-1], upper_bound)
+
+    # Case 4: there are more than 1 local maximum and 1/b^2 lies between two of them
+    # We negate both the array elements and 1/b^2 so the logic mirrors an increasing array
+    idx = bisect_right(local_maxima, -inverse_b2, key=lambda x: -x)
+    return (photon_sph[idx - 1], photon_sph[idx])
+
+def find_rmin(b, r_phs, inner_edge, radial_fun, radial_params, areal, areal_params):
+    """
+    Finds the minimum radius of the trajectory using Brent's method. 
+
+    Parameters:
+        b (float): impact parameter of the photon trajectory
+        r_phs (array): array with the position of photon spheres (maxima) of the potential
+        inner_edge (float): value of the r coordinate of the inner edge (event horizon, throat, etc.)
+        potential (callable): effective potential
+
+    Returns:
+        i)  If b > bmin, then rmin is found by solving V(r)-1/b^2 = 0
+        ii) If b < bmin, then rmin = inner_edge.
+    """
+    pot = lambda r: potential(r, radial_fun, radial_params, areal, areal_params) # V(r)
+    photon_sph, local_maxima = get_increasing_maxima(r_phs, pot)
+    bounds = find_interval(1/b**2, photon_sph, local_maxima) # Interval for Brent's method
+    fun = lambda r: pot(r)-1/b**2
+    if fun(bounds[0])*fun(bounds[1]) >= 0: # No root if there is no sign change
+        root = 0
+    else:
+        root, results = optimize.brentq(fun, *bounds, full_output=True)
+    return max( max(root, inner_edge) , MINIMUM_R )
+
+def geodesic_in(phi, r, b, radial_fun, radial_params, areal, areal_params):
+    """Expression for dphi/dr in the incoming null geodesic equation"""
+    areal_params = to_tuple(areal_params)
+    radial_params = to_tuple(radial_params)
+    return -( b / np.sqrt(areal(r,*areal_params)) )/np.sqrt( areal(r,*areal_params) - b**2*radial_fun(r,*radial_params) )
+
+def geodesic_out(phi, r, b, radial_fun, radial_params, areal, areal_params):
+    """Expression for dphi/dr in the outgoing null geodesic equation"""
+    areal_params = to_tuple(areal_params)
+    radial_params = to_tuple(radial_params)
+    return +( b / np.sqrt(areal(r,*areal_params)) )/np.sqrt( areal(r,*areal_params) - b**2*radial_fun(r,*radial_params) )
+
+def compute_outgoing(r_phs, inner_edge, rmin) -> bool:
+    """Returns a boolean that tells whether to compute outgoing geodesic after reaching rmin"""
+    compute = False
+    if (len(r_phs)>0): # There is at least 1 photon sphere
+        innermost_photon_sphere = np.array(r_phs).min()
+        if (innermost_photon_sphere < MINIMUM_R):
+            if (rmin > MINIMUM_R):
+                compute = True
+        # if (rmin > inner_edge) and (innermost_photon_sphere > 0): # Probamos con inner_edge mejor
+        else:
+            # print('Hola')
+            if (rmin > inner_edge) and (rmin > MINIMUM_R): # Probamos con inner_edge mejor
+                compute = True
+    else: # There is no photon sphere
+        compute = True
+    return compute
+
+def compute_geodesic(b, r_phs, inner_edge, radial_fun, radial_params, areal, areal_params,
+                     Npoints=DEFAULT_NPOINTS, r0=DEFAULT_R0):
+    """
+    Computes the null geodesic trajectory in Schwarzschild spacetime.
+    
+    Integrates the geodesic equations to trace light ray paths. For incoming rays,
+    integrates from r0 down to rmin. For rays escaping to infinity (rmin > 3),
+    also integrates the outgoing trajectory from rmin back to r0.
+
+    Parameters:
+        b (float): Impact parameter in units of M=1
+        Npoints (int): Number of radial points for integration. Default: DEFAULT_NPOINTS
+        r0 (float): Starting radius. Default: DEFAULT_R0
+    
+    Returns:
+        tuple[np.ndarray, np.ndarray]: (rr, phi) where rr is the radial coordinate 
+            array and phi is the azimuthal angle array along the geodesic
+    """ 
+    rmin = find_rmin(b, r_phs, inner_edge, radial_fun, radial_params, areal, areal_params)
+    rr = np.geomspace(r0, rmin, Npoints) # We must ensure rmin > 0 in find_rmin for np.geomspace
+
+    phi0 = b/rr[0] # good approximation for r0>>rSch and better than phi0=0
+    phi = integrate.odeint(
+        geodesic_in, phi0, rr, (b,radial_fun,radial_params,areal,areal_params)
+    ).reshape(-1,)
+    phi = phi[~np.isnan(phi)]
+    rr = rr[:len(phi)]
+
+    # NOTE: does not work properly with high r0 and low Npoints for outgoing geodesics
+    # FIXME: si len(r_phs)=0, solo integra incoming.
+    if compute_outgoing(r_phs, inner_edge, rmin):
+        rout = rr[::-1]
+        phi0 = 2*phi[-1]-phi[-2] # Linear approx. for next angle. Required for strict monotonicity!!
+        phi_out = integrate.odeint(
+            geodesic_out, phi0, rout, (b,radial_fun,radial_params,areal,areal_params)
+        ).reshape(-1,)
+        rr = np.concatenate([rr,rout])
+        phi = np.concatenate([phi,phi_out])
+
+    return (rr,phi)
+
+
+if __name__=="__main__":
+
+    def g_rr(r: float, dummy) -> float:
+        """Radial function g^{rr} of the Schwarzschild metric in units of M=1"""
+        return 1 - 2./r
+
+    def g_thth(r: float, dummy) -> float:
+        """Areal radius squared g^{theta theta} of the Schwarzschild in units of M=1"""
+        return r**2
+
+    # Dictionary codifying Schwarzschild metric and required params
+    Schwarzschild_kwargs = {
+        'r_phs': [3.,],         # Photon sphere at r=3M
+        'inner_edge': 2.,       # Inner edge of disk at horizon r=2M
+        'radial_fun': g_rr,     # Above defined radial function
+        'radial_params': None,  # g_rr has no additional params
+        'areal': g_thth,        # Above defined areal radius squared
+        'areal_params': None,   # g_thth has no additional params
+    }
+
+
+    rr, phi = compute_geodesic(3, **Schwarzschild_kwargs)
+    print(rr, phi)