Move ShotProps initializer from base_engine.py to trajectory_data.py

Author: dbookstaber

py_ballisticcalc.exts/py_ballisticcalc_exts/base_engine.pyx

@@ -34,7 +34,7 @@ from py_ballisticcalc_exts.v3d cimport (
 from py_ballisticcalc.unit import Angular, Unit, Velocity, Distance, Energy, Weight
 from py_ballisticcalc.exceptions import ZeroFindingError, RangeError, OutOfRangeError, SolverRuntimeError
 from py_ballisticcalc.engines.base_engine import create_base_engine_config
-from py_ballisticcalc.trajectory_data import HitResult, TrajFlag
+from py_ballisticcalc.trajectory_data import HitResult, TrajFlag, ShotProps
 
 
 __all__ = (
@@ -265,7 +265,9 @@ cdef class CythonizedBaseIntegrationEngine:
         self._init_trajectory(shot_info)
         object = self._integrate(range_limit_ft, range_step_ft, time_step, filter_flags, dense_output)
         self._free_trajectory()
-        return HitResult(shot_info, object[0], filter_flags > 0, object[1])
+        props = ShotProps.from_shot(shot_info)
+        props.filter_flags = filter_flags
+        return HitResult(props, object[0], filter_flags > 0, object[1])
 
     cdef void _free_trajectory(CythonizedBaseIntegrationEngine self):
         if self._wind_sock is not NULL:

py_ballisticcalc/engines/base_engine.py

@@ -8,15 +8,14 @@
 from dataclasses import dataclass, asdict
 from enum import Enum, auto
 
-from typing_extensions import List, Optional, NamedTuple, Union, Tuple, Dict, TypedDict, TypeVar
+from typing_extensions import Optional, NamedTuple, Union, Tuple, Dict, TypedDict, TypeVar
 
 from py_ballisticcalc.conditions import Shot, Wind
-from py_ballisticcalc.drag_model import DragDataPoint
 from py_ballisticcalc.exceptions import ZeroFindingError, OutOfRangeError, SolverRuntimeError
 from py_ballisticcalc.generics.engine import EngineProtocol
 from py_ballisticcalc.logger import logger
 from py_ballisticcalc.trajectory_data import *
-from py_ballisticcalc.unit import Distance, Angular, Velocity, Weight
+from py_ballisticcalc.unit import Distance, Angular
 from py_ballisticcalc.vector import Vector
 
 __all__ = (
@@ -317,32 +316,16 @@ def get_calc_step(self) -> float:
         """Get step size for integration."""
         return self._config.cStepMultiplier
 
-    def _init_trajectory(self, shot_info: Shot) -> ShotProps:
+    def _init_trajectory(self, shot: Shot) -> ShotProps:
         """
         Converts Shot properties into floats dimensioned in internal units.
 
         Args:
             shot_info (Shot): Information about the shot.
         """
-        return ShotProps(
-            shot=shot_info,
-            bc=shot_info.ammo.dm.BC,
-            curve=calculate_curve(shot_info.ammo.dm.drag_table),
-            mach_list=_get_only_mach_data(shot_info.ammo.dm.drag_table),
-            look_angle_rad=shot_info.look_angle >> Angular.Radian,
-            twist_inch=shot_info.weapon.twist >> Distance.Inch,
-            length_inch=shot_info.ammo.dm.length >> Distance.Inch,
-            diameter_inch=shot_info.ammo.dm.diameter >> Distance.Inch,
-            weight_grains=shot_info.ammo.dm.weight >> Weight.Grain,
-            barrel_elevation_rad=shot_info.barrel_elevation >> Angular.Radian,
-            barrel_azimuth_rad=shot_info.barrel_azimuth >> Angular.Radian,
-            sight_height_ft=shot_info.weapon.sight_height >> Distance.Foot,
-            cant_cosine=math.cos(shot_info.cant_angle >> Angular.Radian),
-            cant_sine=math.sin(shot_info.cant_angle >> Angular.Radian),
-            alt0_ft=shot_info.atmo.altitude >> Distance.Foot,
-            calc_step=self.get_calc_step(),
-            muzzle_velocity_fps=shot_info.ammo.get_velocity_for_temp(shot_info.atmo.powder_temp) >> Velocity.FPS,
-        )
+        props = ShotProps.from_shot(shot)
+        props.calc_step = self.get_calc_step()
+        return props
 
     def find_max_range(self, shot_info: Shot, angle_bracket_deg: Tuple[float, float] = (0, 90)) -> Tuple[
         Distance, Angular]:
@@ -822,16 +805,3 @@ def _integrate(self, props: ShotProps, range_limit_ft: float, range_step_ft: flo
             HitResult: Object describing the trajectory.
         """
         raise NotImplementedError
-
-
-def _get_only_mach_data(data: List[DragDataPoint]) -> List[float]:
-    """
-    Extracts Mach values from a list of DragDataPoint objects.
-
-    Args:
-        data (List[DragDataPoint]): A list of DragDataPoint objects.
-
-    Returns:
-        List[float]: A list containing only the Mach values from the input data.
-    """
-    return [dp.Mach for dp in data]

py_ballisticcalc/trajectory_data.py

@@ -244,9 +244,9 @@ class ShotProps:
     cant_cosine: float  # Cosine of the cant angle
     cant_sine: float  # Sine of the cant angle
     alt0_ft: float  # Initial altitude in feet
-    calc_step: float  # Calculation step size
     muzzle_velocity_fps: float  # Muzzle velocity in feet per second
     stability_coefficient: float = field(init=False)
+    calc_step: float = field(init=False)  # Calculation step size
     filter_flags: Union[TrajFlag, int] = field(init=False)
 
     def __post_init__(self):
@@ -260,6 +260,28 @@ def winds(self) -> Tuple[Wind, ...]:
     def look_angle(self) -> Angular:
         return Angular.Radian(self.look_angle_rad)
 
+    @classmethod
+    def from_shot(cls, shot: Shot) -> 'ShotProps':
+        """Initializes a ShotProps instance from a Shot instance."""
+        return cls(
+            shot=shot,
+            bc=shot.ammo.dm.BC,
+            curve=calculate_curve(shot.ammo.dm.drag_table),
+            mach_list=_get_only_mach_data(shot.ammo.dm.drag_table),
+            look_angle_rad=shot.look_angle >> Angular.Radian,
+            twist_inch=shot.weapon.twist >> Distance.Inch,
+            length_inch=shot.ammo.dm.length >> Distance.Inch,
+            diameter_inch=shot.ammo.dm.diameter >> Distance.Inch,
+            weight_grains=shot.ammo.dm.weight >> Weight.Grain,
+            barrel_elevation_rad=shot.barrel_elevation >> Angular.Radian,
+            barrel_azimuth_rad=shot.barrel_azimuth >> Angular.Radian,
+            sight_height_ft=shot.weapon.sight_height >> Distance.Foot,
+            cant_cosine=math.cos(shot.cant_angle >> Angular.Radian),
+            cant_sine=math.sin(shot.cant_angle >> Angular.Radian),
+            alt0_ft=shot.atmo.altitude >> Distance.Foot,
+            muzzle_velocity_fps=shot.ammo.get_velocity_for_temp(shot.atmo.powder_temp) >> Velocity.FPS,
+        )
+    
     def drag_by_mach(self, mach: float) -> float:
         """
         Calculates a standard drag factor (SDF) for the given Mach number.  Where:
@@ -535,6 +557,18 @@ def calculate_curve(data_points: List[DragDataPoint]) -> List[CurvePoint]:
     return curve
 
 
+def _get_only_mach_data(data: List[DragDataPoint]) -> List[float]:
+    """
+    Extracts Mach values from a list of DragDataPoint objects.
+
+    Args:
+        data (List[DragDataPoint]): A list of DragDataPoint objects.
+
+    Returns:
+        List[float]: A list containing only the Mach values from the input data.
+    """
+    return [dp.Mach for dp in data]
+
 # # use ._get_only_mach_data with ._calculate_by_curve_and_mach_list because it's faster
 # def calculate_by_curve(data: List[DragDataPoint], curve: List[CurvePoint], mach: float) -> float:
 #     """
@@ -660,7 +694,7 @@ class HitResult:
         extra (bool): Whether special points (TrajFlag > 0) were requested.
         error (Optional[RangeError]): RangeError, if any.
     """
-    shot: ShotProps
+    props: ShotProps
     trajectory: list[TrajectoryData] = field(repr=False)
     extra: bool = False
     error: Optional[RangeError] = None
@@ -681,6 +715,11 @@ def __check_extra__(self):
                 f"Use Calculator.fire(..., extra_data=True)"
             )
 
+    def __check_flag__(self, flag: Union[TrajFlag, int]):
+        if not self.props.filter_flags & flag:
+            raise AttributeError(f"{TrajFlag.name(flag)} was not requested in trajectory. "
+                                  f"Use Calculator.fire(..., extra_data=True)")
+
     def zeros(self) -> list[TrajectoryData]:
         """
         Returns:
@@ -690,7 +729,7 @@ def zeros(self) -> list[TrajectoryData]:
             AttributeError: If extra_data was not requested.
             ArithmeticError: If zero crossing points are not found.
         """
-        self.__check_extra__()
+        self.__check_flag__(TrajFlag.ZERO)
         data = [row for row in self.trajectory if row.flag & TrajFlag.ZERO]
         if len(data) < 1:
             raise ArithmeticError("Can't find zero crossing points")
@@ -702,9 +741,9 @@ def flag(self, flag: Union[TrajFlag, int]) -> Optional[TrajectoryData]:
             TrajectoryData: First TrajectoryData row with the specified flag.
 
         Raises:
-            AttributeError: If extra_data was not requested.
+            AttributeError: If flag was not requested.
         """
-        self.__check_extra__()
+        self.__check_flag__(flag)
         for row in self.trajectory:
             if row.flag & flag:
                 return row
@@ -934,7 +973,7 @@ def danger_space(self,
         target_height_half = target_height.raw_value / 2.0
 
         target_row = self.get_at('slant_distance', target_at_range)
-        is_climbing = target_row.angle.raw_value - self.shot.look_angle.raw_value > 0
+        is_climbing = target_row.angle.raw_value - self.props.look_angle.raw_value > 0
         slant_height_begin = target_row.slant_height.raw_value + (-1 if is_climbing else 1) * target_height_half
         slant_height_end = target_row.slant_height.raw_value - (-1 if is_climbing else 1) * target_height_half
         try:
@@ -950,7 +989,7 @@ def danger_space(self,
                            target_height,
                            begin_row,
                            end_row,
-                           self.shot.look_angle)
+                           self.props.look_angle)
 
     def dataframe(self, formatted: bool = False) -> 'DataFrame':  # type: ignore
         """