Equivalent Time Determination Process

To establish the equivalent time in a different length pool the following factors have to be allowed for:

1. Difference in distance actually covered.
2. The time benefit/deficit of executing more or less turns during the swim

As stated in the introduction the actual factors used have been influenced by the original tables.

The full process comprises:

1. Convert the actual swim time achieved to the equivalent time in a 50m pool.
2. Compute the equivalent pool time 50m pool time to the time in the desired pool length(s).

The first step process involves using the turning speed factors for the event and the difference in distance covered between the actual pool length for the swim and a 50m pool.

The second step then involves using the same turning speed factors and the new distance and pool length to convert from 50m pool length to the desired pool length.

The second step – 50m pool length to desired pool length – is expressed as:

Converted Time = T50 * PoolMeasure – TurnVal * (NumTurnperH – 1)

Where:

T50 = Time in a 50m pool

PoolMeasure = Event distance factor

TurnVal  = Time per turn – The time in seconds attributed to execution of a single turn

NumTurnperH  = Number of turns per 100 in the required length pool.

The Time per turn is determined by the relationship:

TurnVal = TurnFactor / T50

Where TurnFactor is provided by the LookUp table shown below.

The table also shows the PoolMeasure (Event Distance Factor) for each event in Imperial yards pools.

The PoolMeasure (Event Distance Factor) value for metric and "36 2/3y", "27 1/2y" pools is the same constant for all events on the basis that the distance covered does not vary by very much between the two categories, i.e. 100m v 110 yds, up to 1500m v 1650 yds. ( – BUT note that 1650 yards is a special case)

Example:

100m Backstroke in a 50m pool in 63.5 seconds

The Time per turn is determined by the relationship:

TurnVal = TurnFactor / T50 = 40.5/63.5 = 0.63779527

For a 25m pool there is no difference in the distance swum, therefore Poolmeasure = 1 and the extra number of turns = 2.

The converted time is therefore

            63.5 * 1 - 0.63779527 * 2 = 62.22 seconds

Rounded to nearest tenth and truncated = 62.2 seconds

For a 33 1/3 yds pool there is a difference in distance swum, therefore PoolMeasure = 0.91187 and the extra number of turns = 1

The converted time is therefore

            63.5 * 0.91187  - 0.63779527 * 1 = 57.2659 seconds

Rounded to nearest tenth and truncated = 57.3 seconds

The first step – conversion from the actual length pool in which the swim was made to the 50m equivalent is slightly more complicated.

The expression for pool length conversion is:

Converted Time = T50 * PoolMeasure – TurnVal * (NumTurnperH – 1)

To calculate the time when converted to 50m pool length we need to solve the equation for T50.

Generalising the above equation we have:

Converted Time = T50 * PoolMeasure – (TurnFactor / T50) * (NumTurnperH – 1)

This involves solving the quadratic equation:

PoolMeasure * T50 * T50 – ActualTime * T50 - TurnFactor * (NumTurnperH – 1)

to obtain the T50 value.

Example:

100 yds Backstroke in a 25 yd pool in 56.6 seconds

For a 25 yard pool there is a difference in distance swum, therefore PoolMeasure = 0.91187 and the extra number of turns = 2

TurnFactor = 40.5 as before

NumTurnperH = 3

The quadratic to be solved is:

0.91187 * T50 * T50 – 56.6 * T50 – 40.5 * 2 = 0

So that

            T50 = 63.51979

Which is consistent with our starting point for step2.

NOTE – The free download <EqvTime> program from the SPORTSYSTEMS website provides the means of confirming the accuracy of any software developed by other parties that are not working with the SPORTSYSTEMS provided DLL.

This program also identifies the event and pool length combinations for which conversion is provided.

Summary

Step 1

Retrieve the Pool Length parameters for the Pool in which the time was achieved - the From Pool

The parameters are:

1.      PoolMeasFlag =          1 - "50m", "33 1/3m", "25m", "20m"

2 - "36 2/3y", "27 1/2y"

3 - "33 1/3y", "25y", "20y"

2.      NumTurnPH – Number of turns per 100

1 - "50m"

2 - "33 1/3m", "36 2/3y", "33 1/3y"

3 - "25m", "27 1/2y", "25y"

4 - "20m", "20y"

Step 2

Check for recognised pool length – (PoolMeasFlag <> 0 and NumTurnPH <> 0)

Step 3

Check that the event stroke and distance is consistent with the From Pool length

Step 4

Check that the Time field contains a valid time and get numeric seconds from user input text

Step 5

If actual time achieved was not in a 50m pool then convert the time to the 50m pool equivalent. The following parameters are required:

PoolMeasure – Factor to allow for distance covered

Case 1 Pool Length - "50m", "33 1/3m", "25m", "20m"          PoolMeasure = 1

Case 2 Pool Length - "36 2/3y", "27 1/2y"                            PoolMeasure = 1.006041

Case 3 Pool Length – "33 1/3y", "25y", "20y"                       PoolMeasure from table below

TurnFactor – Factor to determine time per turn

NumbTurn – Number of extra turns per 100

Distance – 50,100,200,400,800,1500 except when 1650 yards in a 25 yard pool

TimeTo50 = (swtime + Sqr(swtime * swtime + 4 * PoolMeasure * TurnFactor * NumbTurn)) / (2 * PoolMeasure)

Step 6

Convert time in 50m. to equivalent time in the required pool length

1. Retrieve the Pool Length parameters for the Pool to which the time is to be converted- the To Pool
2. Retrieve the turn and distance correction factors for the new pool length

Convert turn factor to a time per turn

3. TurnVal = TurnFactor / Timeval * (Distance / 100)

Check for special case of 1500 in Yards pool

  DistImp = Distance

  If Evntcode = 6 And PoolMeasFlag = 3 Then

    DistImp = 1650

  End If

The following conversions are not catered for:

• 1650 yards in a 2 or 4 turns/100 pool
• 200 I.M. in 2 or 4 turns/100 pool
• 50 any stroke in a 2 or 4 turns/100 pool

Do the conversion

Allowance for different distance covered

DistTime = Timeval * PoolMeasure

Allowance for extra turns

TurnTime = TurnVal * (DistImp / 100) * (NumTurnPH - 1)

Round to nearest tenth

ConvTime = DistTime - TurnTime + 0.05

The time has been rounded to nearest tenth so truncate to prevent display of the hundredths. Convert to alpha format and express as MM:SS.T