Questions about distance

[gambon2010]

At, for example 300 yards, should the distance used to make corrections be the distance on the sight line, or should there be some sort of compensation? For example, I've drawn the intersection of the trajectory at 300m

[gambon2010]

@dbookstaber

[gambon2010]

Shouldn't the correction when the look angle is not 0 be smaller than when it is 0? With the current version of the library if i input 30 degrees look angle, the correction is bigger than if I'm shooting at 0 degrees look angle.
@dbookstaber

[dbookstaber]

We have to be careful to keep track of what the correction's baseline is.

Let's start with a standard example:

zero = Shot(weapon=Weapon(sight_height=2), ammo=Ammo(DragModel(0.22, TableG7), mv=Velocity.FPS(2600)))
calc = Calculator()
zero_distance = Distance.Yard(100)
zero_elevation = calc.set_weapon_zero(zero, zero_distance)
print(f'Barrel elevation for {zero_distance} zero: {zero_elevation << PreferredUnits.adjustment}')

With look angle of 0° the barrel elevation from the sight line to hit zero at 100 yards is 1.334mil. If we are zeroing for a 100-yard target at a look_angle of 30° then the barrel elevation is only 1.288mil:

new_shot = Shot(weapon=Weapon(sight_height=2), ammo=Ammo(DragModel(0.22, TableG7), mv=Velocity.FPS(2600)))
new_shot.look_angle = Angular.Degree(30)
new_elevation = calc.set_weapon_zero(new_shot, zero_distance)
print(f'Barrel elevation for {zero_distance} zero: {new_elevation << PreferredUnits.adjustment}')

Now let's look at what adjustment is needed to hit zero at 300 yards in each case:

0° look_angle

trajectory = calc.fire(zero, trajectory_range=500)
new_target_distance = Distance.Yard(300)
new_target = trajectory.get_at_distance(new_target_distance)
print(f'Zero trajectory hits {new_target.target_drop << PreferredUnits.drop}'
      f' at {(new_target.distance << PreferredUnits.distance)}')
hold = Angular(-new_target.drop_adj.unit_value, new_target.drop_adj.units)
print(f'Sight adjustment to hit {(new_target.distance << PreferredUnits.distance)} target'
      f' is {(hold << PreferredUnits.adjustment)}')

Zero trajectory hits -15.3inch at 300.0yd
Sight adjustment to hit 300.0yd target is 1.441mil

30° look_angle

high_trajectory = calc.fire(new_shot, trajectory_range=500, trajectory_step=100)
new_target_distance = Distance.Yard(300)
new_target = high_trajectory.get_at_distance(new_target_distance)
print(f'Zero trajectory hits {new_target.target_drop << PreferredUnits.drop}'
      f' at {(new_target.distance << PreferredUnits.distance)}')
hold = Angular(-new_target.drop_adj.unit_value, new_target.drop_adj.units)
print(f'Sight adjustment to hit {(new_target.distance << PreferredUnits.distance)} target'
      f' is {(hold << PreferredUnits.adjustment)}')

Zero trajectory hits -19.0inch at 300.0yd
Sight adjustment to hit 300.0yd target is 1.553mil

Confusion

At this point you're likely confused: it should not require a larger adjustment to hit a target when shooting at an angle!

So we have to remember that when shooting at an angle there's a look_distance and a horizontal distance. In this case:

new_target.look_distance << PreferredUnits.distance

gives us <Distance: 346.4yd>. So the trajectory is calculated along horizontal distance, not look_distance. When we asked for the angle to 300 yards, we got the adjustment for a horizontal distance of 300 yards, which is a look_distance of 346 yards.

If we meant to get the adjustment for a look_distance of 300 yards we have to convert that into the horizontal distance (which we will see is 277 yards):

horizontal_distance = Distance(math.cos(new_shot.look_angle >> Angular.Radian)
                      * new_target_distance.unit_value, new_target_distance.units)
high_trajectory = calc.fire(new_shot, trajectory_range=500, extra_data=True)
new_target = high_trajectory.get_at_distance(horizontal_distance)
print(f'Zero trajectory hits {new_target.target_drop << PreferredUnits.drop}'
      f' at {(new_target.distance << PreferredUnits.distance)}')
hold = Angular(-new_target.drop_adj.unit_value, new_target.drop_adj.units)
print(f'Sight adjustment to hit {(new_target.distance << PreferredUnits.distance)} target'
      f' is {(hold << PreferredUnits.adjustment)}')

Zero trajectory hits -14.9inch at 277.2yd
Sight adjustment to hit 277.2yd target is 1.322mil

This is consistent with our intuition.

Can we make this more clear?

As shown here, there is definitely room for improvements to (a) avoid confusion between look_distance and horizontal distance, and (b) make it easier to switch between the two. And while we're at it either switch the signs on "adjustments" or rename them so that they are clearly describing the drop instead of the adjustment to correct for the drop.

[gambon2010]

this makes a lot more sense, thanks for taking the time to explain everything =)

[dbookstaber]

Thank you for thinking hard about this! I just created this issue to address these things. It would be great if you can propose specifications based on how you expected these things to work.

[gambon2010]

I'll think about what I can add as a description to the issue, should add something by the end of the week!