Courses, CourseLegs and TimingLines

Overview

A course and timing lines has to be properly defined to allow the correct sequencing of events to allow timing. This section covers the design considerations and final design rational for implementing the Course and TimingLine constructs.

Common Course Types

Simple, linear courses

In the simplest of forms a course consist out of a single stretch between a start and finish line. The start line could be a virtual construct, where the StartGroup time is manually determined. The finish line records the final outcome of each participant’s race.

@startuml

start :StartLine; :FinishLine; stop

@enduml

Lap racing

In a lap race a participant is crossing the same line multiple times, where each lap is "rolled out" to create a virtual, linear progressing of the course.

Simple lap course

@startuml start :StartLine; repeat :FinishLine; repeat while (LapCount < MaxLaps) stop @enduml

A lap race could also have a lead-in section before the laps are started.

The lap count can be unbounded, creating the possibility to have a time based race, i.e. where riders ride laps for 1 hours and then finish.

A lap race has the concept of a finish time as well as laps covered.
Lap couse with lead-in legs

@startuml start :StartLine; :Checkpoint1; :Checkpoint2; repeat :FinishLine; repeat while () stop @enduml

Similarly, it is possible to have a lead-out section.

@startuml start :StartLine; repeat :LapCheckpoint; repeat while (LapCount < MaxLaps) :Checkpoint; :FinishLine; stop @enduml

Complex course

In more complicated scenarios more than one course leg can cross the same timing line. In these scenarios the progression along the virtual, linear progression of the race must be tracked. It is therefore also required to track each crossing.

In these types of races a compromise has to be made between catering for missed tag reads (rider did cross, but tag did not register) and participants taking "short cuts". The latter can be mitigated by proper course design that allows sufficient intermediate checkpoints for the system to confirm correct progress along the course before crossing the same timing line again.

Multiple courses over the same timing lines

In the most complex cases multiple courses could be using the same timing lines simultaniously. The most simplist form of this is Individual Pursuit on a track, where two participants start at differnt staring points, but cross the same lines.

Rider starting at back straight IP line

@startuml start :IPBS; repeat :IPFS; :FIN; :200m; :IPBS; repeat while (LapCount < MaxLaps) stop @enduml

Rider starting at back straight IP line

@startuml start :IPFS; repeat :FIN; :200m; :IPBS; :IPFS; repeat while (LapCount < MaxLaps) stop @enduml

Course Implementation

A course is divided into one or more CourseLegs.

A course leg runs from one timing line to another timing line. It is not the timing line itself.

Each course requires a start determination, which could be set using a device on a start line, manually determined or calculated via post processing. In either case a StartLine is automatically defined, which could function with or without a device.

Each CourseLeg is then defined, with the first leg starting at the StartLine and finishing at another line. Subsequent legs can then be added, with the possibility that some may even pass along the same path as previous legs.

In races where laps are required a LapGroup can be added, over one or more successive legs, to control looping over those legs. In addition to the system keeping track of the leg progress it will then also keep track of the LapGroup count.

When the MaxCount for a LapGroup is not set the span will terminate once the next leg, subsequent to the LapSpan, is crossed by the first participant.

The LapGroup will calculate the average speed of each rider and once at least one lap is completed will give a warning if any subsequent lap is more than 50% out on the previous, average times.