geometry-generator 0.5.0__py3-none-any.whl

geometry_generator/__init__.py

@@ -0,0 +1,34 @@
+"""Public package interface for geometry_generator."""
+
+# --------------------------------------------------
+# load necessary modules
+# --------------------------------------------------
+from importlib.metadata import (
+    PackageNotFoundError,
+    version,
+)
+
+from geometry_generator.blunted_tangent_ogive import BluntedTangentOgive
+from geometry_generator.blunted_wedge import BluntedWedge
+from geometry_generator.moldline import Moldline, sample_moldline
+from geometry_generator.profile import Profile2D
+from geometry_generator.writers import write_moldline
+
+# --------------------------------------------------
+# resolve package version
+# --------------------------------------------------
+try:
+    __version__ = version("geometry-generator")
+except PackageNotFoundError:
+    __version__ = "0+unknown"
+
+
+__all__ = [
+    "BluntedTangentOgive",
+    "BluntedWedge",
+    "Moldline",
+    "Profile2D",
+    "__version__",
+    "sample_moldline",
+    "write_moldline",
+]

geometry_generator/blunted_tangent_ogive.py

@@ -0,0 +1,362 @@
+"""2D spherically blunted tangent ogive, optionally followed by a cylinder (upper half only).
+
+The profile is the meridian of an axisymmetric body: a spherical nose, a tangent
+ogive, and an optional cylinder of the base radius.
+
+Sharp ogive (the definition the length refers to)
+-------------------------------------------------
+A tangent ogive of length L and base radius R is a circular arc of radius
+
+    rho = (R^2 + L^2) / (2 R)
+
+from the sharp tip to the base, where it is tangent to the cylinder (slope 0).
+Blunting replaces the tip with a sphere of radius r_n, centred on the axis and
+tangent to the arc from inside. The blunted body is therefore shorter than L.
+
+Coordinates
+-----------
+- origin at the stagnation point, x downstream, y up (y is the radius)
+- nose: circular arc with centre (r_n, 0). Its polar angle phi is measured from
+  the stagnation point and runs from 0 to phi_j = 90 deg - theta_t
+- theta_t: slope angle where nose and ogive meet, cos(theta_t) = (rho - R) / (rho - r_n)
+- ogive: circular arc with centre (x_b, R - rho), where x_b = r_n + (rho - r_n) sin(theta_t)
+  is the base position. Its angle alpha from the vertical runs from theta_t at the
+  junction down to 0 at the base point (x_b, R)
+- cylinder (optional): straight line y = R from x_b to x_b + cylinder_length
+
+The sharp ogive's tip would lie at x = x_b - L, upstream of the stagnation point.
+
+At both junctions position and slope are continuous. Curvature jumps from 1 / r_n
+to 1 / rho at the nose/ogive junction, and from 1 / rho to 0 at the base.
+
+Arc length s runs from 0 at the stagnation point, around the nose, along the
+ogive, and along the cylinder:
+
+- nose:     0 <= s <= s_j, with s_j = r_n phi_j and phi = s / r_n
+- ogive:    s_j < s <= s_b, with s_b = s_j + rho theta_t and alpha = theta_t - (s - s_j) / rho
+- cylinder: s_b < s <= s_b + cylinder_length
+
+At a junction itself, the curvature is reported as the upstream piece's value.
+"""
+
+# --------------------------------------------------
+# load necessary modules
+# --------------------------------------------------
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from geometry_generator.profile import check_arc_length, check_sharp_profile_inputs
+
+
+# --------------------------------------------------
+# blunted tangent ogive profile
+# --------------------------------------------------
+@dataclass(frozen=True, slots=True)
+class BluntedTangentOgive:
+    """Spherical nose, tangent ogive, optional cylinder; upper half, parametrized by arc length.
+
+    Attributes:
+        nose_radius: Nose radius r_n [m], smaller than the base radius.
+        length: Length L of the sharp ogive, tip to base [m]; the blunted body is shorter.
+        base_radius: Base radius R [m], smaller than L.
+        cylinder_length: Length of the cylinder after the base [m]; 0 for none.
+    """
+
+    nose_radius: float
+    length: float
+    base_radius: float
+    cylinder_length: float = 0.0
+
+    def __post_init__(self) -> None:
+        # validate inputs
+        if self.nose_radius <= 0.0:
+            raise ValueError(f"nose_radius must be positive, got {self.nose_radius}")
+        if self.base_radius <= 0.0:
+            raise ValueError(f"base_radius must be positive, got {self.base_radius}")
+        if self.cylinder_length < 0.0:
+            raise ValueError(f"cylinder_length must not be negative, got {self.cylinder_length}")
+
+        # a tangent ogive needs L > R (otherwise the arc bulges forward past the tip)
+        if self.length <= self.base_radius:
+            raise ValueError(
+                f"length ({self.length}) must be greater than base_radius ({self.base_radius})"
+            )
+
+        # the nose sphere must fit inside the ogive (r_n = R would be a sphere-cylinder)
+        if self.nose_radius >= self.base_radius:
+            raise ValueError(
+                f"nose_radius ({self.nose_radius}) must be smaller than base_radius "
+                f"({self.base_radius})"
+            )
+
+    # --------------------------------------------------
+    # derived geometry
+    # --------------------------------------------------
+    @property
+    def ogive_radius(self) -> float:
+        """Radius rho = (R^2 + L^2) / (2 R) of the ogive arc."""
+        rho = (self.base_radius**2 + self.length**2) / (2.0 * self.base_radius)
+        return rho
+
+    @property
+    def tangency_angle(self) -> float:
+        """Slope angle theta_t [rad] where the nose meets the ogive."""
+        rho = self.ogive_radius
+        theta_t = math.acos((rho - self.base_radius) / (rho - self.nose_radius))
+        return theta_t
+
+    @property
+    def junction_angle(self) -> float:
+        """Polar angle phi_j = 90 deg - theta_t [rad] where the nose meets the ogive."""
+        phi_junction = 0.5 * math.pi - self.tangency_angle
+        return phi_junction
+
+    @property
+    def junction_point(self) -> tuple[float, float]:
+        """Coordinates (x_j, y_j) of the tangency point between nose and ogive."""
+        theta_t = self.tangency_angle
+        x_junction = self.nose_radius * (1.0 - math.sin(theta_t))
+        y_junction = self.nose_radius * math.cos(theta_t)
+        return x_junction, y_junction
+
+    @property
+    def junction_arc_length(self) -> float:
+        """Arc length s_j = r_n phi_j where the nose meets the ogive."""
+        s_junction = self.nose_radius * self.junction_angle
+        return s_junction
+
+    @property
+    def base_point(self) -> tuple[float, float]:
+        """Coordinates (x_b, R) of the ogive base, where the cylinder starts."""
+        rho = self.ogive_radius
+        x_base = self.nose_radius + (rho - self.nose_radius) * math.sin(self.tangency_angle)
+        return x_base, self.base_radius
+
+    @property
+    def base_arc_length(self) -> float:
+        """Arc length s_b = s_j + rho theta_t at the ogive base."""
+        s_base = self.junction_arc_length + self.ogive_radius * self.tangency_angle
+        return s_base
+
+    @property
+    def sharp_tip_x(self) -> float:
+        """x position of the sharp ogive's tip, x_b - L (upstream of the stagnation point)."""
+        x_base, _ = self.base_point
+        x_tip = x_base - self.length
+        return x_tip
+
+    @property
+    def total_length(self) -> float:
+        """Arc length of the whole profile, s_b + cylinder_length."""
+        total = self.base_arc_length + self.cylinder_length
+        return total
+
+    @property
+    def junctions(self) -> NDArray[np.float64]:
+        """Arc lengths where the pieces meet: nose/ogive, and ogive/cylinder if there is one."""
+        if self.cylinder_length > 0.0:
+            junctions = np.array([self.junction_arc_length, self.base_arc_length])
+        else:
+            junctions = np.array([self.junction_arc_length])
+        return junctions
+
+    # --------------------------------------------------
+    # public evaluation methods
+    # --------------------------------------------------
+    def point(self, s: ArrayLike) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Return the surface coordinates at arc length s.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Tuple (x, y) of arrays with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # validate inputs
+        s_arr = check_arc_length(s, self.total_length)
+        r_n = self.nose_radius
+        rho = self.ogive_radius
+        x_base, y_base = self.base_point
+
+        # nose: circular arc around (r_n, 0)
+        phi = self._nose_angle(s_arr)
+        x_nose = r_n - r_n * np.cos(phi)
+        y_nose = r_n * np.sin(phi)
+
+        # ogive: circular arc around (x_b, R - rho), angle alpha from the vertical
+        alpha = self._ogive_angle(s_arr)
+        x_ogive = x_base - rho * np.sin(alpha)
+        y_ogive = (y_base - rho) + rho * np.cos(alpha)
+
+        # cylinder: straight line at the base radius
+        x_cylinder = x_base + (s_arr - self.base_arc_length)
+        y_cylinder = np.full_like(s_arr, y_base)
+
+        # pick the piece each s belongs to
+        pieces = self._pieces(s_arr)
+        x = np.select(pieces, [x_nose, x_ogive, x_cylinder])
+        y = np.select(pieces, [y_nose, y_ogive, y_cylinder])
+
+        return x, y
+
+    def tangent(self, s: ArrayLike) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Return the unit tangent at arc length s, pointing towards increasing s.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Tuple (tx, ty) of arrays with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # validate inputs
+        s_arr = check_arc_length(s, self.total_length)
+
+        # nose: derivative of (r_n - r_n cos(phi), r_n sin(phi)) w.r.t. s
+        phi = self._nose_angle(s_arr)
+        tx_nose = np.sin(phi)
+        ty_nose = np.cos(phi)
+
+        # ogive: derivative of (x_b - rho sin(alpha), ... + rho cos(alpha)), d(alpha)/ds = -1/rho
+        alpha = self._ogive_angle(s_arr)
+        tx_ogive = np.cos(alpha)
+        ty_ogive = np.sin(alpha)
+
+        # cylinder: along x
+        tx_cylinder = np.ones_like(s_arr)
+        ty_cylinder = np.zeros_like(s_arr)
+
+        # pick the piece each s belongs to
+        pieces = self._pieces(s_arr)
+        tx = np.select(pieces, [tx_nose, tx_ogive, tx_cylinder])
+        ty = np.select(pieces, [ty_nose, ty_ogive, ty_cylinder])
+
+        return tx, ty
+
+    def normal(self, s: ArrayLike) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Return the unit normal at arc length s, pointing away from the body into the flow.
+
+        The normal is the tangent rotated by +90 degrees, (nx, ny) = (-ty, tx).
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Tuple (nx, ny) of arrays with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # build from the tangent (validates s)
+        tx, ty = self.tangent(s)
+
+        # rotate by +90 degrees
+        nx = -ty
+        ny = tx
+
+        return nx, ny
+
+    def curvature(self, s: ArrayLike) -> NDArray[np.float64]:
+        """Return the surface curvature at arc length s.
+
+        Curvature is 1 / r_n on the nose, 1 / rho on the ogive (both convex, positive)
+        and 0 on the cylinder. At a junction the upstream piece's value is returned.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Array of curvatures [1/m] with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # validate inputs
+        s_arr = check_arc_length(s, self.total_length)
+
+        # constant on each piece
+        pieces = self._pieces(s_arr)
+        kappa = np.select(pieces, [1.0 / self.nose_radius, 1.0 / self.ogive_radius, 0.0])
+
+        return kappa
+
+    def sharp_profile(
+        self, x_end: float, n_points: int
+    ) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """The sharp tangent ogive the blunted body follows, from its tip.
+
+        Past the base the profile continues as the cylinder the ogive is tangent to,
+        whether or not this body has one.
+
+        Args:
+            x_end: Downstream end [m], past the sharp tip (sharp_tip_x).
+            n_points: Points, evenly spaced in x.
+
+        Returns:
+            Tuple (x, y) of arrays, with y = 0 at the tip.
+
+        Raises:
+            ValueError: If x_end doesn't lie past the tip, or n_points < 2.
+        """
+
+        # validate inputs
+        x_tip = self.sharp_tip_x
+        check_sharp_profile_inputs(x_tip, x_end, n_points)
+        x_base, y_base = self.base_point
+        rho = self.ogive_radius
+
+        # ogive arc from the tip to the base (centre at (x_b, R - rho)), cylinder past it
+        x = np.linspace(x_tip, x_end, n_points)
+        distance_to_base = np.maximum(x_base - x, 0.0)
+        y = np.sqrt(np.maximum(rho**2 - distance_to_base**2, 0.0)) + y_base - rho
+
+        # the tip lies on the axis (rounding would leave a tiny y there)
+        y[0] = 0.0
+
+        return x, y
+
+    # --------------------------------------------------
+    # private helpers
+    # --------------------------------------------------
+    def _pieces(self, s_arr: NDArray[np.float64]) -> list[NDArray[np.bool_]]:
+        """Masks for the nose, ogive and cylinder pieces (in that order)."""
+
+        # build: each junction belongs to the upstream piece
+        on_nose = s_arr <= self.junction_arc_length
+        on_ogive = ~on_nose & (s_arr <= self.base_arc_length)
+        on_cylinder = s_arr > self.base_arc_length
+        pieces = [on_nose, on_ogive, on_cylinder]
+
+        return pieces
+
+    def _nose_angle(self, s_arr: NDArray[np.float64]) -> NDArray[np.float64]:
+        """Nose polar angle phi, clipped to the nose so other pieces don't overshoot it."""
+
+        # convert arc length to angle
+        phi = np.minimum(s_arr, self.junction_arc_length) / self.nose_radius
+        return phi
+
+    def _ogive_angle(self, s_arr: NDArray[np.float64]) -> NDArray[np.float64]:
+        """Ogive angle alpha from the vertical, clipped to [0, theta_t]."""
+
+        # distance along the ogive, clipped to the ogive piece
+        ogive_arc = self.ogive_radius * self.tangency_angle
+        distance_on_ogive = np.clip(s_arr - self.junction_arc_length, 0.0, ogive_arc)
+
+        # convert to angle: theta_t at the junction, 0 at the base
+        alpha = self.tangency_angle - distance_on_ogive / self.ogive_radius
+        return alpha

geometry_generator/blunted_wedge.py

@@ -0,0 +1,291 @@
+"""2D circular nose followed by a straight body at a half-angle (upper half only).
+
+The same profile describes three test geometries:
+
+- half_angle = 0: flat plate with a circular leading edge (blunted plate)
+- half_angle > 0, planar: blunted wedge
+- half_angle > 0, axisymmetric: meridian of a sphere-cone (e.g. 7 deg)
+
+Planar vs axisymmetric is a choice for the grid and the solver, not the profile.
+
+Coordinates
+-----------
+- origin at the stagnation point, x downstream, y up
+- nose: circular arc with centre (r_n, 0). Its polar angle phi is measured from
+  the stagnation point and runs from 0 to phi_j = 90 deg - half_angle
+- junction (tangency point): (r_n (1 - sin theta), r_n cos theta), theta = half_angle
+- body: straight line from the junction in direction (cos theta, sin theta),
+  ending at x = L (L is measured from the nose tip along x)
+
+At the junction the arc's tangent equals the body direction, so the profile is
+continuous in position and slope. Curvature jumps from 1 / r_n to 0 there.
+
+Arc length s runs from 0 at the stagnation point, around the nose, to the end of
+the body:
+
+- nose:  0 <= s <= s_j, with s_j = r_n phi_j and phi = s / r_n
+- body: s_j < s <= s_j + (L - x_j) / cos theta
+
+Equal steps in s on the nose are equal steps in angle, and the nose normals point
+radially away from the nose centre, so a constant-height grid around the nose is a
+polar grid. At s = s_j exactly, the curvature is reported as the nose value.
+
+Sharp body
+----------
+For half_angle > 0 the straight body, extended forward, meets the axis at the
+virtual tip x = r_n (1 - 1 / sin theta), upstream of the stagnation point. The sharp
+wedge or cone from there is the body the blunted one follows behind its nose.
+"""
+
+# --------------------------------------------------
+# load necessary modules
+# --------------------------------------------------
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from geometry_generator.profile import check_arc_length, check_sharp_profile_inputs
+
+
+# --------------------------------------------------
+# blunted wedge profile
+# --------------------------------------------------
+@dataclass(frozen=True, slots=True)
+class BluntedWedge:
+    """Circular nose plus straight body, upper half, parametrized by arc length.
+
+    With the default half_angle = 0 this is the blunted flat plate.
+
+    Attributes:
+        nose_radius: Nose radius r_n [m].
+        length: Axial length L [m], measured from the nose tip (stagnation point).
+        half_angle: Body half-angle theta [deg], 0 <= theta < 90.
+    """
+
+    nose_radius: float
+    length: float
+    half_angle: float = 0.0
+
+    def __post_init__(self) -> None:
+        # validate inputs
+        if self.nose_radius <= 0.0:
+            raise ValueError(f"nose_radius must be positive, got {self.nose_radius}")
+        if not 0.0 <= self.half_angle < 90.0:
+            raise ValueError(f"half_angle must lie in [0, 90) deg, got {self.half_angle}")
+
+        # the body must extend past the junction
+        x_junction = self.nose_radius * (1.0 - math.sin(math.radians(self.half_angle)))
+        if self.length <= x_junction:
+            raise ValueError(
+                f"length must be greater than the junction x position ({x_junction}), "
+                f"got {self.length}"
+            )
+
+    # --------------------------------------------------
+    # derived geometry
+    # --------------------------------------------------
+    @property
+    def junction_angle(self) -> float:
+        """Polar angle phi_j = 90 deg - half_angle [rad] where the nose meets the body."""
+        phi_junction = 0.5 * math.pi - math.radians(self.half_angle)
+        return phi_junction
+
+    @property
+    def junction_point(self) -> tuple[float, float]:
+        """Coordinates (x_j, y_j) of the tangency point between nose and body."""
+        theta = math.radians(self.half_angle)
+        x_junction = self.nose_radius * (1.0 - math.sin(theta))
+        y_junction = self.nose_radius * math.cos(theta)
+        return x_junction, y_junction
+
+    @property
+    def junction_arc_length(self) -> float:
+        """Arc length s_j = r_n phi_j where the nose meets the body."""
+        s_junction = self.nose_radius * self.junction_angle
+        return s_junction
+
+    @property
+    def total_length(self) -> float:
+        """Arc length of the whole profile, s_j + (L - x_j) / cos(theta)."""
+        theta = math.radians(self.half_angle)
+        x_junction, _ = self.junction_point
+        body_length = (self.length - x_junction) / math.cos(theta)
+        total = self.junction_arc_length + body_length
+        return total
+
+    @property
+    def junctions(self) -> NDArray[np.float64]:
+        """Arc lengths where the pieces meet: the nose-body junction."""
+        junctions = np.array([self.junction_arc_length])
+        return junctions
+
+    @property
+    def sharp_tip_x(self) -> float:
+        """x position of the sharp body's virtual tip, r_n (1 - 1 / sin theta).
+
+        Raises:
+            ValueError: If half_angle is 0 (a flat plate has no sharp tip).
+        """
+        if self.half_angle == 0.0:
+            raise ValueError("a flat plate (half_angle = 0) has no sharp tip")
+        theta = math.radians(self.half_angle)
+        x_tip = self.nose_radius * (1.0 - 1.0 / math.sin(theta))
+        return x_tip
+
+    # --------------------------------------------------
+    # public evaluation methods
+    # --------------------------------------------------
+    def point(self, s: ArrayLike) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Return the surface coordinates at arc length s.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Tuple (x, y) of arrays with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # validate inputs
+        s_arr = check_arc_length(s, self.total_length)
+        r_n = self.nose_radius
+        s_j = self.junction_arc_length
+        theta = math.radians(self.half_angle)
+        x_j, y_j = self.junction_point
+
+        # nose: circular arc around (r_n, 0)
+        # clip to the nose range so body points don't produce angles past phi_j
+        phi = np.minimum(s_arr, s_j) / r_n
+        x_nose = r_n - r_n * np.cos(phi)
+        y_nose = r_n * np.sin(phi)
+
+        # body: straight line from the junction at the half-angle
+        distance_on_body = s_arr - s_j
+        x_body = x_j + distance_on_body * math.cos(theta)
+        y_body = y_j + distance_on_body * math.sin(theta)
+
+        # pick the piece each s belongs to
+        on_nose = s_arr <= s_j
+        x = np.where(on_nose, x_nose, x_body)
+        y = np.where(on_nose, y_nose, y_body)
+
+        return x, y
+
+    def tangent(self, s: ArrayLike) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Return the unit tangent at arc length s, pointing towards increasing s.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Tuple (tx, ty) of arrays with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # validate inputs
+        s_arr = check_arc_length(s, self.total_length)
+        s_j = self.junction_arc_length
+        theta = math.radians(self.half_angle)
+
+        # nose: derivative of (r_n - r_n cos(phi), r_n sin(phi)) w.r.t. s
+        phi = np.minimum(s_arr, s_j) / self.nose_radius
+        tx_nose = np.sin(phi)
+        ty_nose = np.cos(phi)
+
+        # body: constant direction (cos theta, sin theta)
+        tx_body = np.full_like(s_arr, math.cos(theta))
+        ty_body = np.full_like(s_arr, math.sin(theta))
+
+        # pick the piece each s belongs to
+        on_nose = s_arr <= s_j
+        tx = np.where(on_nose, tx_nose, tx_body)
+        ty = np.where(on_nose, ty_nose, ty_body)
+
+        return tx, ty
+
+    def normal(self, s: ArrayLike) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Return the unit normal at arc length s, pointing away from the body into the flow.
+
+        The normal is the tangent rotated by +90 degrees, (nx, ny) = (-ty, tx). With
+        s running along the wall and the normal into the flow, (s, n) is a
+        right-handed (counter-clockwise) pair.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Tuple (nx, ny) of arrays with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # build from the tangent (validates s)
+        tx, ty = self.tangent(s)
+
+        # rotate by +90 degrees
+        nx = -ty
+        ny = tx
+
+        return nx, ny
+
+    def curvature(self, s: ArrayLike) -> NDArray[np.float64]:
+        """Return the surface curvature at arc length s.
+
+        Curvature is 1 / r_n on the nose (convex, positive) and 0 on the body. It
+        jumps at the junction; s = s_j itself returns the nose value.
+
+        Args:
+            s: Arc length(s) in [0, total_length].
+
+        Returns:
+            Array of curvatures [1/m] with the shape of s.
+
+        Raises:
+            ValueError: If any s lies outside [0, total_length].
+        """
+
+        # validate inputs
+        s_arr = check_arc_length(s, self.total_length)
+
+        # constant on each piece
+        on_nose = s_arr <= self.junction_arc_length
+        kappa = np.where(on_nose, 1.0 / self.nose_radius, 0.0)
+
+        return kappa
+
+    def sharp_profile(
+        self, x_end: float, n_points: int
+    ) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """The sharp wedge or cone the blunted body follows, from its virtual tip.
+
+        Args:
+            x_end: Downstream end [m], past the virtual tip.
+            n_points: Points, evenly spaced in x.
+
+        Returns:
+            Tuple (x, y) of arrays, with y = 0 at the tip.
+
+        Raises:
+            ValueError: If half_angle is 0, x_end doesn't lie past the tip, or
+                n_points < 2.
+        """
+
+        # validate inputs
+        x_tip = self.sharp_tip_x
+        check_sharp_profile_inputs(x_tip, x_end, n_points)
+
+        # straight line from the virtual tip at the half-angle
+        theta = math.radians(self.half_angle)
+        x = np.linspace(x_tip, x_end, n_points)
+        y = (x - x_tip) * math.tan(theta)
+
+        return x, y

geometry_generator/cli/__init__.py

@@ -0,0 +1,5 @@
+"""Command-line interface for geometry-generator."""
+
+from geometry_generator.cli.app import app
+
+__all__ = ["app"]