Handicaps

Top level functions

Module providing various handicap functionalities.

archeryutils.handicaps.arrow_score(handicap, target, handicap_sys, arw_d=None)

Calculate the average arrow score for a given target and handicap rating.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate score for

• target (targets.Target) – A Target class specifying the target to be used

• handicap_sys (str | HandicapScheme) – identifier for the handicap system to use

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

Returns:

average expected arrow score for this handicap and target

Return type:

NDArray[np.float64]

Warning

Using a custom value for arrow diameter may give values that differ from the official handicap scheme values.

Examples

Expected arrow score on a WA720 70m target, using the AGB handicap system at a handicap of 10 can be calculated with:

>>> import archeryutils as au
>>> from archeryutils import handicaps as hc
>>> my720target = au.Target("10_zone", 122, 70.0)
>>> hc.arrow_score(10.0, my720target, "AGB")
9.401182682963338

It can also be passed an array of handicaps:

>>> hc.arrow_score(np.array([10.0, 50.0, 100.0]), my720target, "AGB")
array([9.40118268, 6.05227962, 0.46412515])

archeryutils.handicaps.handicap_from_score(score, rnd, handicap_sys, arw_d=None, int_prec=False)

Calculate the handicap of a given score on a given round.

Parameters:

• score (float) – score achieved on the round

• rnd (rounds.Round) – the rounds.Round object to calculate the handicap for

• handicap_sys (str | HandicapScheme) – identifier for the handicap system to use

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

• int_prec (bool, default False) – display results as integers? default = False if True decimal results accurate to 2dp

Returns:

Handicap for score. Has type int if int_prec is True, else float.

Return type:

int | float

Examples

Handicap for a score of 999 on a WA 1440 (90m) using the AGB scheme can be calculated as:

>>> import archeryutils as au
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> hc.handicap_from_score(999, wa_outdoor.wa1440_90, "AGB")
43.999964586102706

To get an integer value as would appear in the handicap tables use int_prec=True:

>>> au.handicap_functions.handicap_from_score(
...     999, wa_outdoor.wa1440_90, "AGB", hc_params, int_prec=True
... )
44.0

archeryutils.handicaps.handicap_scheme(handicap_sys, **kwargs)

Create a HandicapScheme subclass for a requested handicap scheme.

Parameters:

• handicap_sys (str | HandicapScheme) – String identifying the handicap scheme class to be generated, or an existing HandicapScheme

• \**kwargs (float) – Various kwargs defining custom values of parameters as appropriate for hc_sys

Returns:

a subclass of HandicapScheme as appropriate for the inputs

Return type:

HandicapScheme

Raises:

ValueError – If a handicap scheme is requested for which there is no defined class.

See also

handicap_scheme.HandicapScheme

The HandicapScheme class

handicap_scheme_agb.HandicapAGB

The AGB HandicapScheme subclass and associated \**kwargs

handicap_scheme_agb.HandicapAGBold

The AGBold HandicapScheme subclass and associated \**kwargs

handicap_scheme_aa.HandicapAA

The AA HandicapScheme subclass and associated \**kwargs

handicap_scheme_aa.HandicapAA2

The AA2 HandicapScheme subclass and associated \**kwargs

Examples

To generate a HandicapScheme class using the Archery GB (AGB) handicap scheme:

>>> from archeryutils import handicaps as hc
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme
HandicapScheme('AGB')

archeryutils.handicaps.score_for_passes(handicap, rnd, handicap_sys, arw_d=None, rounded_score=True)

Calculate the expected score for all passes in a round at a given handicap.

Parameters:

• handicap (ArrayLike) – handicap value(s) to calculate score for

• rnd (rounds.Round) – A Round class specifying the round being shot

• handicap_sys (str | HandicapScheme) – identifier for the handicap system to use

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

• rounded_score (bool, default True) – round score to integer value? Note the sum of rounded passes may not be the same as the rounded round score

Returns:

average score for each pass in the round

Return type:

NDArray

Examples

Expected score for each pass on a WA1440 90m, using the AGB handicap system at a handicap of 10 can be calculated with the code below which returns an array with one score for each pass that makes up the round:

>>> import archeryutils as au
>>> from archeryutils import handicaps as hc
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> hc.score_for_passes(10.0, wa_outdoor.wa1440_90, "AGB")
array([322.84091528, 338.44257659, 338.66395001, 355.87959411])

It can also be passed an array of handicaps:

>>> hc.score_for_passes(
...     np.array([10.0, 50.0, 100.0]),
...     wa_outdoor.wa1440_90,
...     "AGB",
... )
array([[322.84091528, 162.76200686,   8.90456718],
       [338.44257659, 217.88206641,  16.70850537],
       [338.66395001, 216.74407488,  16.41855209],
       [355.87959411, 288.77185611,  48.47897177]])

archeryutils.handicaps.score_for_round(handicap, rnd, handicap_sys, arw_d=None, rounded_score=True)

Calculate the expected score for a round at a given handicap.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate score for

• rnd (rounds.Round) – A Round class specifying the round being shot

• handicap_sys (str | HandicapScheme) – identifier for the handicap system to use

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

• rounded_score (bool, default True) – round score to integer value?

Returns:

round_score – average score of the round for this set of parameters

Return type:

NDArray[np.float64]

Examples

Expected score for a WA1440 90m, using the AGB handicap system at a handicap of 10 can be calculated with:

>>> import archeryutils as au
>>> from archeryutils import handicaps as hc
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> hc.score_for_round(10.0, wa_outdoor.wa1440_90, "AGB")
1356.0
>>> au.handicap_equations.score_for_round(
...     wa_outdoor.wa1440_90, 10.0, rounded_score=False
... )
1355.8270359849505

It can also be passed an array of handicaps:

>>> hc.score_for_round(
...     np.array([10.0, 50.0, 100.0]),
...     wa_outdoor.wa1440_90,
... )
array([1356.,  887.,   91.])

HandicapTable Class

class archeryutils.handicaps.HandicapTable(handicap_sys, hcs, round_list, rounded_scores=True, int_prec=True, clean_gaps=True, arrow_d=None)

Bases: object

Class to generate and store a handicap table.

Parameters:

• handicap_sys (str | HandicapScheme) – identifier for the handicap system to use

• hcs (ArrayLike) – handicap values to calculate scores for

• round_list (list[rounds.Round]) – list of Round classes to show in the handicap table

• rounded_scores (bool, default True) – round scores to integer value?

• int_prec (bool, default True) – display numbers in table as integers rather than decimals to improve appearance

• clean_gaps (bool, default True) – clean out gaps of repeated scores (using only first occurrence) gaps will be filled with -9999 (int_prec=True) or np.nan (int_prec=False)

• arrow_d (float | None, default None) – user-specified arrow diameter in [metres]

hc_sys

HandicapScheme class to be used in constructing this table

Type:

HandicapScheme

round_list

list of Round classes to show in the handicap table

Type:

list[rounds.Round]

rounded_scores

round scores to integer value?

Type:

bool

int_prec

display numbers in table as integers rather than decimals to improve appearance

Type:

bool

clean_gaps

clean out gaps of repeated scores (using only first occurrence)

Type:

bool

hcs

handicap values to calculate scores for

Type:

NDArray[np.float64]

table

the generated handicap table containing appropriate score values

Type:

NDArray[np.float64 | np.int\_]

print()

Print handicap table to screen/stdout.

Examples

>>> import archeryutils as au
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> from archeryutils import handicaps as hc
>>> agb_table = hc.HandicapTable(
...     "AGB",
...     [1.0, 2.0, 3.0, 4.0, 5.0],
...     [wa_outdoor.wa1440_90, wa_outdoor.wa1440_70, wa_outdoor.wa1440_60],
... )
>>> agb_table.print()
      Handicap WA 1440 (90m) WA 1440 (70m) WA 1440 (60m)
             1          1396          1412          1427
             2          1393          1409          1425
             3          1389          1406          1423
             4          1385          1403          1420
             5          1380          1399          1418

Return type:

None

to_csv(csvfile)

Save handicap table as a csv file.

Parameters:

csvfile (str) – csv filepath to save to.

Examples

>>> import archeryutils as au
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> from archeryutils import handicaps as hc
>>> agb_table = hc.HandicapTable(
...     "AGB",
...     [1.0, 2.0, 3.0, 4.0, 5.0],
...     [wa_outdoor.wa1440_90, wa_outdoor.wa1440_70, wa_outdoor.wa1440_60],
... )
>>> agb_table.to_csv("mycsvfile.csv")
Writing handicap table to csv...Done.

Return type:

None

to_file(filename)

Save handicap table to text file.

Parameters:

filename (str) – filepath to save table to.

Examples

>>> import archeryutils as au
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> from archeryutils import handicaps as hc
>>> agb_table = hc.HandicapTable(
...     "AGB",
...     [1.0, 2.0, 3.0, 4.0, 5.0],
...     [wa_outdoor.wa1440_90, wa_outdoor.wa1440_70, wa_outdoor.wa1440_60],
... )
>>> agb_table.to_file("mytextfile.txt")
Writing handicap table to file...Done.

Return type:

None

HandicapScheme Classes

class archeryutils.handicaps.HandicapScheme

Bases: ABC

Abstract Base Class to represent a generic handicap scheme.

name

The name of the handicap scheme.

Type:

str

arw_d_out

diameter of an outdoor arrow [metres] for this scheme, default 5.5e-3

Type:

float

arw_d_in

diameter of an indoor arrow [metres] for this scheme, default 9.3e-3

Type:

float

desc_scale

does the scheme use a descending scale (lower handicap is better), default True

Type:

bool

scale_bounds

Reasonable upper and lower bounds on the handicap scale for bounding searches

Type:

NDArray[np.float64]

max_score_rounding_lim

Limit to round the max score to when searching depends on scheme rounding method e.g. round() vs. ceil() etc.

Type:

float

See also

handicap_scheme_agb.HandicapAGB

The AGB HandicapScheme subclass and associated \**kwargs

handicap_scheme_agb.HandicapAGBold

The AGBold HandicapScheme subclass and associated \**kwargs

handicap_scheme_aa.HandicapAA

The AA HandicapScheme subclass and associated \**kwargs

handicap_scheme_aa.HandicapAA2

The AA2 HandicapScheme subclass and associated \**kwargs

arrow_score(handicap, target, arw_d=None)

Calculate the average arrow score for a given target and handicap rating.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate score for

• target (targets.Target) – A Target class specifying the target to be used

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

Returns:

s_bar – average score of the arrow for this set of parameters

Return type:

NDArray[np.float64]

References

• The construction of the graduated handicap tables for target archery Lane, D (2013)

Examples

Expected arrow score on a WA720 70m target at a handicap of 10, using the AGB handicap system (via the HandicapSchemeAGB subclass) can be calculated with:

>>> import archeryutils as au
>>> import archeryutils.handicaps as hc
>>> my720target = au.Target("10_zone", 122, 70.0)
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme.arrow_score(10.0, my720target)
9.401182682963338

It can also be passed an array of handicaps:

>>> agb_scheme.arrow_score(np.array([10.0, 50.0, 100.0]), my720target)
array([9.40118268, 6.05227962, 0.46412515])

handicap_from_score(score, rnd, arw_d=None, int_prec=False)

Calculate the handicap of a given score on a given round.

Parameters:

• score (float) – score achieved on the round

• rnd (rounds.Round) – the rounds.Round object to calculate the handicap for

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

• int_prec (bool, default False) – display results as integers? default = False decimal results accurate to 2dp from rootfinder

Returns:

handicap – Handicap for score. Has type int if int_prec is True, else float.

Return type:

int | float

Raises:

ValueError – If an invalid score for the given round is provided.

Examples

Handicap for a score of 999 on a WA 1440 (90m), using the AGB handicap system (via the HandicapSchemeAGB subclass), can be calculated using:

>>> import archeryutils as au
>>> import archeryutils.handicaps as hc
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme.score_for_round(wa_outdoor.wa1440_90, 10.0)
>>> agb_scheme.handicap_from_score(999, wa_outdoor.wa1440_90)
43.999964586102706

To get an integer value as would appear in the handicap tables use int_prec=True:

>>> agb_scheme.handicap_from_score(999, wa_outdoor.wa1440_90, int_prec=True)
44.0

score_for_passes(handicap, rnd, arw_d=None, rounded_score=True)

Calculate the expected score for all passes in a round at a given handicap.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate score for

• rnd (rounds.Round) – A Round class specifying the round being shot

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

• rounded_score (bool, default True) – round score to integer value? Note: sum of rounded passes may not be the same as the rounded round score

Returns:

pass_scores – average score for each pass in the round

Return type:

NDArray[np.float64]

Examples

Expected score for each pass on a WA1440 90m at a handicap of 10, using the AGB handicap system (via the HandicapSchemeAGB subclass) can be calculated with the following code which returns an array with one score for each pass that makes up the round:

>>> import archeryutils as au
>>> import archeryutils.handicaps as hc
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme.score_for_passes(10.0, wa_outdoor.wa1440_90)
array([322.84091528, 338.44257659, 338.66395001, 355.87959411])

It can also be passed an array of handicaps:

>>> agb_scheme.score_for_passes(
...     np.array([10.0, 50.0, 100.0]), wa_outdoor.wa1440_90
... )
array([[322.84091528, 162.76200686,   8.90456718],
       [338.44257659, 217.88206641,  16.70850537],
       [338.66395001, 216.74407488,  16.41855209],
       [355.87959411, 288.77185611,  48.47897177]])

score_for_round(handicap, rnd, arw_d=None, rounded_score=True)

Calculate the expected score for a round at a given handicap.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate score for

• rnd (rounds.Round) – A Round class specifying the round being shot

• arw_d (float | None, default None) – user-specified arrow diameter in [metres]

• rounded_score (bool, default True) – round score to integer value?

Returns:

round_score – average score of the round for this set of parameters

Return type:

NDArray[np.float64]

Examples

Expected score for a WA1440 90m at a handicap of 10, using the AGB handicap system (via the HandicapSchemeAGB subclass) can be calculated using:

>>> import archeryutils as au
>>> import archeryutils.handicaps as hc
>>> wa_outdoor = au.load_rounds.WA_outdoor
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme.score_for_round(10.0, wa_outdoor.wa1440_90)
1356.0

To get a decimal value of the exact handicap corresponding to the requested score use rounded_score=False:

>>> agb_scheme.score_for_round(
...     wa_outdoor.wa1440_90,
...     10.0,
...     rounded_score=False,
... )
1355.8270359849505

It can also be passed an array of handicaps:

>>> agb_scheme.score_for_round(
...     np.array([10.0, 50.0, 100.0]), wa_outdoor.wa1440_90
... )
array([1356.,  887.,   91.])

sigma_r(handicap, dist)

Calculate radial deviation for a given handicap and distance.

Standard deviation as a proxy for ‘group size’ based on handicap parameters, scheme, and distance. Wraps around sigma_t() and multiplies by distance.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate sigma_r at

• dist (float) – distance to target [metres]

Returns:

sig_r – standard deviation of group size [metres]

Return type:

NDArray[np.float64]

Examples

Deviation (in metres) at a distance of 25m and a handicap of 10, using the AGB handicap system (via the HandicapSchemeAGB subclass) can be calculated with:

>>> import archeryutils.handicaps as hc
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme.sigma_r(10.0, 25.0)
0.023745700245257646

It can also be passed an array of handicaps:

>>> agb_scheme.sigma_r(np.asarray([10.0, 50.0, 100.0]), 25.0)
array([0.0237457 , 0.09401539, 0.5250691 ])

abstract sigma_t(handicap, dist)

Calculate angular deviation for given handicap and distance.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate sigma_t at

• dist (float) – distance to target [metres]

Returns:

sig_t – angular deviation [rad]

Return type:

NDArray[np.float64]

class archeryutils.handicaps.HandicapAGB(datum=6.0, step=3.5, ang_0=0.0005, kd=0.00365)

Bases: HandicapScheme

Class to represent the Archery GB handicap scheme.

This class represents the 2023 handicap scheme by Jack Atkinson.

Parameters:

• datum (float) – offset to set scratch point, default = 6.0,

• step (float) – percentage change in deviation per handicap step, default = 3.5,

• ang_0 (float) – datum angle used in scheme, default = 5.0e-4,

• kd (float) – factor controlling excess dispersion scaling with distance, default = 0.00365,

name

The name of the handicap scheme.

Type:

str=``”AGB”``

arw_d_out

diameter of an outdoor arrow: 5.5e-3 [metres]

Type:

float

arw_d_in

diameter of an indoor arrow 9.3e-3 [metres]

Type:

float

Warning

Using non-default values for the kwargs may produce results that do not match the official values for this scheme. Only change if you are experimenting and know what you are doing!

See also

HandicapScheme

The base class for a handicap scheme from which this is subclassed containing details of additional methods.

sigma_t(handicap, dist)

Calculate angular deviation for given handicap and distance.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate sigma_t at

• dist (float) – distance to target [metres]

Returns:

sig_t – angular deviation [rad]

Return type:

NDArray[np.float64]

Examples

Angular deviation at a distance of 25m, using the AGB handicap system at a handicap of 10 can be calculated with:

>>> import archeryutils.handicaps as hc
>>> agb_scheme = hc.handicap_scheme("AGB")
>>> agb_scheme.sigma_t(10.0, 25.0)
0.0009498280098103058

It can also be passed an array of handicaps:

>>> import numpy as np
>>> agb_scheme.sigma_t(np.array([10.0, 50.0, 100.0]), 25.0)
array([0.00094983, 0.00376062, 0.02100276])

class archeryutils.handicaps.HandicapAGBold(datum=12.9, step=3.6, ang_0=0.0005, k1=1.429e-06, k2=1.07, k3=4.3, p1=2.0)

Bases: HandicapScheme

Class to represent the old (pre-2023) Archery GB handicap scheme by D. Lane.

Parameters:

• datum (float) – offset to set scratch point, default = 12.9,

• step (float) – percentage change in deviation per handicap step, default = 3.6,

• ang_0 (float) – datum angle used in scheme, default = 5.0e-4,

• k1 (float) – constant k1 in the handicap equation, default = 1.429e-6,

• k2 (float) – constant k2 in the handicap equation, default = 1.07,

• k3 (float) – constant k3 in the handicap equation, default = 4.3,

• p1 (float) – exponent of distance scaling, default = 2.0,

name

The name of the handicap scheme.

Type:

str=``”AGBold”``

arw_d_out

diameter of an outdoor arrow: 7.14e-3 [metres]

Type:

float

arw_d_in

diameter of an indoor arrow 7.14e-3 [metres]

Type:

float

Warning

Using non-default values for the kwargs may produce results that do not match the official values for this scheme. Only change if you are experimenting and know what you are doing!

See also

HandicapScheme

The base class for a handicap scheme from which this is subclassed containing details of additional methods.

sigma_t(handicap, dist)

Calculate angular deviation for given handicap and distance.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate sigma_t at

• dist (float) – distance to target [metres]

Returns:

sig_t – angular deviation [rad]

Return type:

NDArray[np.float64]

Notes

This is the key part of this scheme. The values are taken from Lane (2013) [1].

References

[1]

Lane, D. (2013). “The Construction of the Graduated Handicap Tables for Target Archery.”

Examples

Angular deviation at a distance of 25m, using the AGBold handicap system at a handicap of 10 can be calculated with:

>>> import archeryutils.handicaps as hc
>>> agbold_scheme = hc.handicap_scheme("AGBold")
>>> agbold_scheme.sigma_t(10.0, 25.0)
0.001126491382794861

It can also be passed an array of handicaps:

>>> import numpy as np
>>> agbold_scheme.sigma_t(np.array([10.0, 50.0, 100.0]), 25.0)
array([0.00112649, 0.00478762, 0.05520862])

class archeryutils.handicaps.HandicapAA(ang_0=0.001, k0=2.37, ks=0.027, kd=0.004)

Bases: HandicapScheme

Class to represent the original Archery Australia scheme by J. Park.

Parameters:

• ang_0 (float) – datum angle used in scheme, default = 1.0e-3,

• k0 (float) – handicap offset to set scratch point, default= 2.37,

• ks (float) – change with each handicap step as a geometric progression, default= 0.027,

• kd (float) – distance scaling factor, default= 0.004,

name

The name of the handicap scheme.

Type:

str=``”AA”``

arw_d_out

diameter of an outdoor arrow: 5.0e-3 [metres]

Type:

float

arw_d_in

diameter of an indoor arrow 9.3e-3 [metres]

Type:

float

Warning

Using non-default values for the kwargs may produce results that do not match the official values for this scheme. Only change if you are experimenting and know what you are doing!

See also

HandicapScheme

The base class for a handicap scheme from which this is subclassed containing details of additional methods.

sigma_t(handicap, dist)

Calculate angular deviation for given handicap and distance.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate sigma_t at

• dist (float) – distance to target [metres]

Returns:

sig_t – angular deviation [rad]

Return type:

NDArray[np.float64]

Notes

This is the key part of this scheme. The values are taken from Park (2014) [2].

References

[2]

Park, J. L. (2014). “Modelling archers’ scores at different distances to quantify score loss due to equipment selection and technique errors.” Proceedings of the Institution of Mechanical Engineers, Part P: Journal of Sports Engineering and Technology, 228(4), 250-258. DOI: 10.1177/175433711453930

Examples

Angular deviation at a distance of 25m, using the AGBold handicap system at a handicap of 10 can be calculated with:

>>> import archeryutils.handicaps as hc
>>> aa_scheme = hc.handicap_scheme("AA")
>>> aa_scheme.sigma_t(10.0, 25.0)
0.012763296491500004

It can also be passed an array of handicaps:

>>> import numpy as np
>>> aa_scheme.sigma_t(np.array([10.0, 50.0, 100.0]), 25.0)
array([0.0127633 , 0.00433436, 0.00112364])

class archeryutils.handicaps.HandicapAA2(ang_0=0.001, k0=2.57, ks=0.027, f1=0.815, f2=0.185, d0=50.0)

Bases: HandicapScheme

Class to represent the updated (2014) Archery Australia scheme by J. Park.

Parameters:

• ang_0 (float) – datum angle used in scheme, default = 1.0e-3,

• k0 (float) – handicap offset to set scratch point, default= 2.57,

• ks (float) – change with each handicap step as a geometric progression, default= 0.027,

• f1 (float) – ‘linear’ scaling factor, default= 0.815,

• f2 (float) – ‘quadratic’ scaling factor, default= 0.185,

• d0 (float) – normalisation distance, default = 50.0,

name

The name of the handicap scheme.

Type:

str=``”AA2”``

arw_d_out

diameter of an outdoor arrow: 5.0e-3 [metres]

Type:

float

arw_d_in

diameter of an indoor arrow 9.3e-3 [metres]

Type:

float

Warning

Using non-default values for the kwargs may produce results that do not match the official values for this scheme. Only change if you are experimenting and know what you are doing!

See also

HandicapScheme

The base class for a handicap scheme from which this is subclassed containing details of additional methods.

sigma_t(handicap, dist)

Calculate angular deviation for given handicap and distance.

Parameters:

• handicap (ArrayLike) – handicap(s) to calculate sigma_t at

• dist (float) – distance to target [metres]

Returns:

sig_t – angular deviation [rad]

Return type:

NDArray[np.float64]

Notes

This is the key part of this scheme. The values are taken from Park (2014) [3].

References

[3]

Park, J. L. (2014). “Modelling archers’ scores at different distances to quantify score loss due to equipment selection and technique errors.” Proceedings of the Institution of Mechanical Engineers, Part P: Journal of Sports Engineering and Technology, 228(4), 250-258. DOI: 10.1177/175433711453930

Examples

Angular deviation at a distance of 25m, using the AGBold handicap system at a handicap of 10 can be calculated with:

>>> import archeryutils.handicaps as hc
>>> aa2_scheme = hc.handicap_scheme("AA2")
>>> aa2_scheme.sigma_t(10.0, 25.0)
0.012800853871823342

It can also be passed an array of handicaps:

>>> import numpy as np
>>> aa2_scheme.sigma_t(np.array([10.0, 50.0, 100.0]), 25.0)
array([0.01280085, 0.00434711, 0.00112695])