pytmosph3r.util.geometry

Module Contents

cos_central_angle(lat0, lon0, lat1, lon1)

Returns cosine of central angle between two points (lat0, lon0) and (lat1, lon1).

intersection_circles(d, r1, r2)

Computes the intersection area of two circles or radii r1 and r2, of which the centers are separated by a distance d.

integrate_circles_intersections(d, r1, r2, func, coeffs)

Integrate func(x) for x

Extracted from batman (Kreidberg 2015)

Parameters:

• func (numba function) – Function to calculate over x

• d (float) – distance between two circle centers.

• r1 (float) – radius of 1st circle

• r2 (float) – radius of 2nd circle

dist(r1, a1, r2, a2)

Distance between two points.

angle_from_sides(r1, r2, r3)

Angle between r1 and r2 in a triangle. r3 is the opposite side.

circular_segment(rS, aS, Rs, r1, a1, r2, a2)

Computes the intersection area of a line (r1, a1) - (r2, a2), with a circle of radius Rs of which the center is (rS, aS).

triangle_surface(r1, a1, r2, a2, r3, a3)

“Surface of a triangle using the coordinates of each vertex.

compute_surface_sector(r, a, a_r, r_a, rS, aS, Rs, n_angular)

Surface area of a sector delimited by (r, a) with the intersections points of with the radius r (angles a_r), and the intersections points with the angles a of the sector (radii r_a). There are two solutions (max) for each.

Parameters:

• r (float) – Radius of sector

• a (float, float) – Delimiting angles of sector

• a_r (tuple) – Intersections with r (2 solutions max)

• r_a (tuple) – Intersections with a (2 angles, and 2 solutions max for each)

• rS (float) – projected distance to star center

• aS (float) – projected angle to star center

• Rs (float) – star radius

• n_angular (float) – Number of angles (simpler calculations if equal to 1)

class PointCircle(radius: float, angle: float)

2D polar coordinates.

radius: float

Radius in meters.

angle: float

Angle in radians.

property coords: Tuple[float, float]

class PointSpherical(radius: float, latitude: float, longitude: float)

3D spherical coordinates.

radius: float

Radius, in meters.

latitude: float

Latitude in radian \([ -\pi/2, +\pi/2]\)

longitude: float

Longitude in radian \([0,2\pi[\)

property coords: Tuple[float, float, float]

class PointCartesian(x: float, y: float, z: float)

3D Cartesian coordinates.

x: float

y: float

z: float

property coords: Tuple[float, float, float]

property norm2: float

property norm: float

fast_solve_latitude(x, latitudes, z_ray, norm_ray, dir_latitude)

class CoordinateSystem(direction: PointCartesian, ray_origin: PointCartesian | None = None)

Computes the intersection of a ray going through ray_origin following the direction direction.

Parameters:

• direction (PointCartesian) – Direction (x,y,z) of the ray.

• ray_origin (PointCartesian) – Cartesian coordinates (x,y,z) of the ray intersection point with the terminator.

direction: PointCartesian

ray_origin: PointCartesian | None = None

radius(x)

latitude(x)

longitude(x)

solve_radius(radii)

solve_longitude(longitudes)

class CartesianCoordinateSystem(latitude: float, longitude: float)

Bases: CoordinateSystem

Same as CoordinateSystem, but initialize the system with a direction and an ray origin given in spherical and polar coordinates, respectively.

spherical_direction

solve_latitude(latitudes)

property y_coeff

coordinates(radius, angle)

Returns coordinates in Cartesian coordinate system of point at (radius, angle)

add_ray_origin(radius, angle)

class CircleIntersection(star, orbit=None, rays=None)

Class to compute the intersection of the cells of the transmittance grid with the star disk.

Parameters:

• star (Star) – Star (including coordinates and size)

• sma (float) – Distance (in \(m\)) between the star and the planet.

• inclination (float) – Orbit inclination (in degrees).

• rays (Rays) – Transmittance grid (including the number of radial and angular rays).

model = None

star

property orbit

property rays

Automatize fetching of rays from transmission / building if necessary.

radial_inter

Intersections with each radius (2 solutions each, max).

angular_inter

Intersections with each angle (2 solutions each, max).

property sma

Distance between planet and star.

property inclination

Inclination of the orbit.

dist(phase=None)

Computes distance of each cell of the transmittance to the star center. Does not recompute if phase is not provided (save computation time).

Parameters:

phase (float, optional) – Phase in radians. Defaults to None.

Returns:

Distance of transmittance cells to star center

Return type:

array

intersections(phase, star=None, sma=None, rays=None)

Computes intersection surfaces between star and the grid of rays.

compute_intersections_points()

Compute intersection points of the star with all radii and angles of the transmittance grid.

compute_intersections_surfaces()