Type declarations examples

Example: an actor declaration

OSC2 code: actor declaration

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum veh_category: [car, truck, motorcycle]
enum track_kind: [single_track, multi_track]

actor my_vehicle:
  category: veh_category
  emergency_vehicle: bool
  track_kind: track_kind

Example: unconditional inheritance

OSC2 code: unconditional inheritance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum rv_category: [motorhome, campervan, caravan, fifth_wheel_trailer, popup_camper, truck_camper]

actor recreational_vehicle:
    category: rv_category
    has_kitchen: bool

actor truck_camper inherits recreational_vehicle:
    keep(category==truck_camper)
    keep(has_kitchen==false)

Example: conditional inheritance

OSC2 code: conditional inheritance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

enum veh_category: [car, truck, motorcycle]
enum track_kind: [single_track, multi_track]


actor my_vehicle:
  category: veh_category
  emergency_vehicle: bool
  track_kind: track_kind


actor my_truck inherits my_vehicle(category == truck):
    num_of_trailers: uint with: keep(it in [0..2])

Example: scenario declaration example 1

OSC2 code: scenario declaration example 1

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario top.something:
    b: bool


# Declaration 1
actor x:
  b: bool

  scenario y:
    do top.something()

Example: scenario declaration example 2

OSC2 code: scenario declaration example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario top.something:
    b: bool


# Declaration 2
actor x:
  b: bool

scenario x.y:
  do top.something()

Example: extend a scenario of a parent actor

OSC2 code: extend a scenario of a parent actor

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario top.something:
    speed: speed


actor x:
  b: bool
  scenario y:
    do something: top.something(speed: default 20kph)

actor z inherits x (b == true):
  extend y:
    keep(something.speed == 30kph)

Example: action/scenario difference

OSC2 code: action/scenario difference

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


actor flying_object inherits physical_object:
    weight: mass
    keep(weight < 10kg)

# action flying_object.fly:
scenario flying_object.fly:
    pos: global_position

Example: enum declaration

OSC2 code: enum declaration

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum car_type: [sedan = 1, truck = 2, bus = 3]

# by default, aggressive = 0, normal = 1
enum my_driving_style: [aggressive, normal, timid]

Example: ambiguous constraint with enum

OSC2 code: ambiguous constraint with enum

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum my_enum: [a, b]

actor my_actor:
    a: int
    x: my_enum with:
        keep(it == a)

Example: resolving ambiguity with 'as()'

OSC2 code: resolving ambiguity with 'as()'

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum my_enum: [a, b]

actor my_actor:
    a: int
    x: my_enum with:
        keep(it == self.a.as(my_enum))

Example: explicit enum literals

OSC2 code: explicit enum literals

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

enum rgb_color: [red, green, blue]
enum cmyk_color: [cyan, magenta, yellow, black]


extend rgb_color: [black]

extend top.main:
  # Example enumeration fields
  my_cmyk_color: cmyk_color = black          # Resolved to cmyk_color!black
  my_new_rgb_color: rgb_color = black        # Resolved to rgb_color!black

  # Resolution in expressions
  # field1: bool = (black == black)            # Could be either type -> error issued
  field2: bool = (rgb_color!black == rgb_color!black)  # True

Example: extend enum

OSC2 code: extend enum

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

enum driving_style: [normal, aggressive]


extend driving_style: [erratic]

Example: extend struct

OSC2 code: extend struct

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

struct storm_data:
    snow_depth: length

extend storm_data:
    var wind_velocity: speed

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

Example: extend scenario

OSC2 code: extend scenario

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"
    set min_test_time = 0second



scenario top.scenario1:
  flag: bool

  do log("Scenario 1 is executing")

scenario top.scenario2:

  do log("Scenario 2 is executing")

scenario top.scenario3:

  do log("Scenario 3 is executing")

extend top.scenario3:

  do scenario2()

extend top.main:

  do serial:
    scenario1()
    scenario3()

Example: extend previous behavior

OSC2 code: extend previous behavior

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set min_test_time = 0sec
    set map = "$FTX_PACKAGES/maps/hooder.xodr"


scenario top.scenario1:
  flag: bool

  do log("Scenario 1 is executing")

extend top.scenario1:

  do serial:
    previous_do()
    log("Extending scenario 1 behavior")

extend top.main:

  do serial:
    scenario1()

Example: modifier

OSC2 code: modifier

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


modifier sut.curving_road:
    gr: road_curvature with:
        keep(it.min_radius == 6meter)
        keep(it.max_radius == 11meter)

extend sut.curving_road:
    keep(gr.direction == right_curve)

Example: constrain global parameter

OSC2 code: constrain global parameter

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


# global count2: uint = 0                   # default constraint not supported yet
global count: uint with: keep(soft it == 0) # soft constraint allowed

struct keep_count:
#    keep(soft count== 1) # constraining global parameter from dynamic struct not allowed

Example: constraint on local/global fields

OSC2 code: constraint on local/global fields

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


global count: uint with: keep(it == 0)

extend top.main:
    count: uint
    keep(count == 2)

Example: modifier declaration for a scenario

OSC2 code: modifier declaration for a scenario

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"
extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario vehicle.to_side_on_curve


modifier vehicle.object_in_road of to_side_on_curve:
    tc: traffic_cone

Example: modifier declaration for an actor

OSC2 code: modifier declaration for an actor

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


modifier sut.curving_road:
    gr: road_curvature 
    keep(gr.min_radius == 6meter)
    keep(gr.max_radius == 11meter)

Example: global modifier for the vehicle actor

OSC2 code: global modifier for the vehicle actor

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"

extend issue_kind: [high_speed_at_end]

# Declaring a global modifier
global modifier vehicle.end_speed_info:
    # Use 'actor' to reference the actor instance
    cover(name: speed_at_end, expression: actor.state.speed, event: end, unit: kph)

    # Simple check
    on @end if actor.state.speed > 50kph:
        other_error(high_speed_at_end, "speed too high at end")

# Disabling a global modifier for a specific actor:
extend top.main:
    vehicle_1: vehicle
    vehicle_2: vehicle

    # Access the modifier field under the actor's end_speed_info
    keep(vehicle_2.end_speed_info.enabled == false)

    do parallel:
        sut.car.drive() with: speed([30..60]kph)
        vehicle_1.drive() with: speed([55..70]kph)
        vehicle_2.drive() with: speed([25..50]kph)
    with:
        duration([3..7]s)

Example: scenario declaration

OSC2 code: scenario declaration

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


# A two-phase scenario
scenario traffic.two_phases:   # Scenario name
    # Define the truck with specific attributes
    truck1: vehicle with:
        keep(it.color == green)
        keep(it.vehicle_category == box_truck)

    # Define the behavior
    do serial:
        phase1: truck1.drive() with:
            speed(speed: 0kph, at: start)
            speed(speed: 10kph, at: end)
        phase2: truck1.drive() with:
            speed(speed: [10..15]kph)

Example: scenario inheritance in type declarations

OSC2 code: scenario inheritance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum my_vehicle_category: [car, truck, motorcycle]
enum my_emergency_vehicle_kind: [fire, police, ambulance]
enum light_kind: [parking, low_beam, high_beam, emergency]

actor my_vehicle:
    category: my_vehicle_category
    emergency_vehicle: bool


actor my_emergency_vehicle inherits my_vehicle(emergency_vehicle == true):
    vehicle_kind: my_emergency_vehicle_kind

scenario my_vehicle.maneuver:
    lights: light_kind

scenario my_emergency_vehicle.maneuver_emergency inherits maneuver(lights == emergency):
    siren: bool with: keep(it == true)

Example: struct declaration

OSC2 code: struct declaration

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


struct my_car_status:
    var time: time
    var current_speed: speed

Example: struct unconditional inheritance

OSC2 code: struct unconditional inheritance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


struct my_collision_data inherits collision_data:
    var other_vehicle_category: vehicle_category

Example: struct conditional inheritance

OSC2 code: struct conditional inheritance

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum storm_type: [rain, ice, snow]

struct storm_data:
    storm: storm_type
    wind: speed

struct snow_storm_data inherits storm_data(storm == snow):
    snow_depth: length

Example: watcher type for exceeded speed limit

OSC2 code: watcher type for exceeded speed limit

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"


# define a watcher type that create intervals
# when the speed of a vehicle exceeds some speed limit
watcher modifier speed_above:
    v: vehicle
    limit: speed
    on @top.w_clk:
        if(data == null):
            if(v.state.speed > limit):
                start_interval()
        else:
            if(v.state.speed <= limit):
                end_interval()


extend top.main:
    watcher s is speed_above(sut.car, 30kph)
    #on @top.clk:
    #    logger.log_info("$(sut.car.state.speed)")
    do serial:
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: start)
            speed([35kph..40kph], at: end)
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: end)

Example: watcher type for maximal speed

OSC2 code: watcher type for maximal speed

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"


# Define watcher data that records a speed
struct speed_watcher_data inherits any_watcher_data:
    var speed: speed
    record(speed, unit: kph)

# Define a watcher type that create intervals
# when the speed of a vehicle exceeds some speed limit,
# and records the maximal exceeding speed
watcher modifier speed_above(speed_watcher_data):
    v: vehicle
    limit: speed

    on @top.clk:
        if(data == null):
            if(v.state.speed > limit):
                start_interval()
        else:
            if(v.state.speed <= limit):
                end_interval()
    on @i_clock:
        if(data.speed < v.state.speed): data.speed = v.state.speed


extend top.main:
    watcher s is speed_above(sut.car, 30kph)
    #on @s.i_clock:
    #    logger.log_info("$(sut.car.state.speed)")
    #on @s.i_end:
    #    logger.log_info("MAX: $(s.data.speed)")
    do serial:
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: start)
            speed([35kph..40kph], at: end)
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: end)

Example: watcher data type that records speed

OSC2 code: watcher data type that records speed

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"


# Define watcher data that records a speed
struct speed_watcher_data inherits any_watcher_data:
    speed: speed
    record(speed, unit: kph)


# Define a watcher type that create intervals
# when the speed of a vehicle exceeds some speed limit,
# and records the average exceeding speed
watcher modifier speed_above(speed_watcher_data):
    v: vehicle
    limit: speed
    var sum: speed # The accumulated speeds during the interval
    var ticks: int # The number of clock cycles during the interval
    on @top.w_clk:
        if(data == null):
            if(v.state.speed > limit):
                sum = 0kph
                ticks = 0
                start_interval()
        else:
            if(v.state.speed <= limit):
                data.speed = sum/ticks
                end_interval()
    on @i_clock:
        sum = sum + v.state.speed
        ticks = ticks + 1


extend top.main:
    watcher s is speed_above(sut.car, 30kph)
    #on @s.i_clock:
    #    logger.log_info("$(sut.car.state.speed), $(s.sum), $(s.ticks)")
    #on @s.i_end:
    #    logger.log_info("AVERAGE: $(s.data.speed)")
    do serial:
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: start)
            speed([35kph..40kph], at: end)
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: end)

Example: a list of speed

OSC2 code: a list of speed

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"

extend top.main:
    slow_vehicle: vehicle
    mid_vehicle: vehicle
    fast_vehicle: vehicle
    speeds: list of speed with:
        keep(speeds.size() == 3)
        keep(speeds[0] in [20..35]kph)
        keep(speeds[1] in [40..55]kph)
        keep(speeds[2] in [60..75]kph)

    do parallel:
       slow_vehicle.drive() with: speed(speeds[0])
       mid_vehicle.drive() with: speed(speeds[1])
       fast_vehicle.drive() with: speed(speeds[2])

Example: using a native method to modify a list

OSC2 code: using a native method to modify a list

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"

extend top.main:
    my_ints: list of int

    def get_lowest(ints: list of int) -> int is:
        return ints.sort(it)[0]

    do serial:
       sut.car.drive() with: duration([4..7]s)
       call logger.log_info("Lowest integer is $(get_lowest(my_ints))")

Example: constraining range type fields

OSC2 code: constraining range type fields

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/straight_long_road.xodr"

struct ranges:
    int_range: range of int
    # constrain the range to a specific range
    keep(int_range == [5..10])

    speed_range: range of speed
    # constrain the range to be within a specific range
    keep(speed_range in [20..50]kph)

    length_range: range of length
    # constrain the range to a specific value
    keep(length_range == 50m)

extend top.main:
    ranges: ranges

    in sut_drive with: speed(ranges.speed_range)
    do  sut_drive: sut.car.drive() with: duration([3..7]s)

Example: providing initial watcher data to start_interval

OSC2 code: providing initial watcher data to start_interval

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/M77_FTX_highway_straight_long_road.xodr"


# Define watcher data that records acceleration
struct speed_watcher_data inherits any_watcher_data:
    var acceleration_when_exceeded: acceleration
    record(acceleration_when_exceeded, unit: mpsps)

# Define a watcher type that create intervals
# when the speed of a vehicle exceeds some speed limit,
# and records the acceleration at the start of the interval
watcher modifier speed_above(speed_watcher_data):
    v: vehicle
    limit: speed

    on @top.clk:
        if(data == null):
            if(v.state.speed > limit):
                var d := new_data()
                d.acceleration_when_exceeded = v.state.road_acceleration.lon
                start_interval(d)
        else:
            if(v.state.speed <= limit):
                end_interval()



extend top.main:
    watcher s is speed_above(sut.car, 30kph)

    do serial:
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: start)
            speed([35kph..40kph], at: end)
        sut.car.drive(duration: [5sec..10sec]) with:
            speed([20kph..25kph], at: end)