Ammo

def calc_powder_sens(self, other_velocity: Union[float, Velocity],
                     other_temperature: Union[float, Temperature]) -> float:
    """Calculate velocity temperature sensitivity and update temp_modifier.

    This method calculates the powder temperature sensitivity coefficient
    based on two known velocity/temperature data points and assigns the
    result to the temp_modifier attribute.

    Args:
        other_velocity: Known velocity at other_temperature.
        other_temperature: Temperature corresponding to other_velocity.

    Returns:
        Temperature modifier in terms of percentage velocity change per 15°C.

    Raises:
        ValueError: If other_velocity and temperature are the same as baseline,
                   making calculation impossible.

    Note:
        The calculation uses the formula:
        temp_modifier = (velocity_delta / temperature_delta) * (15 / lower_velocity)

        This provides a normalized sensitivity value representing the percentage
        change in velocity per 15°C temperature change.

    Example:
        ```python
        # Calculate sensitivity from known velocity drop in cold weather
        sensitivity = ammo.calc_powder_sens(
            other_velocity=Unit.MPS(800),  # Velocity at cold temp
            other_temperature=Unit.Celsius(0)  # Cold temperature
        )
        print(f"Powder sensitivity: {sensitivity:.4f}% per 15°C")

        # The temp_modifier is now automatically set
        print(f"Current temp_modifier: {ammo.temp_modifier}")
        ```
    """
    v0 = self.mv >> Velocity.MPS
    t0 = self.powder_temp >> Temperature.Celsius
    v1 = PreferredUnits.velocity(other_velocity) >> Velocity.MPS
    t1 = PreferredUnits.temperature(other_temperature) >> Temperature.Celsius

    if v0 <= 0 or v1 <= 0:
        raise ValueError("calc_powder_sens requires positive muzzle velocities")
    v_delta = math.fabs(v0 - v1)
    t_delta = math.fabs(t0 - t1)
    v_lower = v1 if v1 < v0 else v0

    if v_delta == 0 or t_delta == 0:
        raise ValueError("other_velocity and temperature can't be same as default")
    self.temp_modifier = v_delta / t_delta * (15 / v_lower)  # * 100
    return self.temp_modifier

def get_velocity_for_temp(self, current_temp: Union[float, Temperature]) -> Velocity:
    """Calculate muzzle velocity adjusted for powder temperature.

    This method calculates the muzzle velocity at a given temperature based
    on the baseline velocity, powder temperature, and temperature sensitivity
    modifier. If powder sensitivity is disabled, returns the baseline velocity.

    Args:
        current_temp: Temperature of the cartridge powder.

    Returns:
        Muzzle velocity corrected for the specified temperature.

    Note:
        The calculation uses the formula:
        adjusted_velocity = baseline_velocity + (temp_modifier / (15 / baseline_velocity)) * temp_delta
        ... where temp_delta is the difference between current_temp and powder_temp.

        If use_powder_sensitivity is False, returns the baseline muzzle velocity regardless of temperature.

    Example:
        ```python
        # Get velocity for current conditions
        cold_velocity = ammo.get_velocity_for_temp(Unit.Celsius(-10))
        hot_velocity = ammo.get_velocity_for_temp(Unit.Celsius(35))

        print(f"Baseline velocity: {ammo.mv}")
        print(f"Cold weather velocity: {cold_velocity}")
        print(f"Hot weather velocity: {hot_velocity}")

        # With powder sensitivity disabled
        ammo.use_powder_sensitivity = False
        constant_velocity = ammo.get_velocity_for_temp(Unit.Celsius(-10))
        # constant_velocity equals ammo.mv regardless of temperature
        ```
    """
    if not self.use_powder_sensitivity:
        return self.mv
    try:
        v0 = self.mv >> Velocity.MPS
        t0 = self.powder_temp >> Temperature.Celsius
        t1 = PreferredUnits.temperature(current_temp) >> Temperature.Celsius
        t_delta = t1 - t0
        muzzle_velocity = self.temp_modifier / (15 / v0) * t_delta + v0
    except ZeroDivisionError:
        muzzle_velocity = 0
    return Velocity.MPS(muzzle_velocity)