Using OSC2 examples

Example: control attribute values with keep()

OSC2 code: control attribute values with keep()

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 traffic.scenario1:
    my_speed: speed

    keep(my_speed < 50kph)

Example: control attribute values with scenario modifiers

OSC2 code: control attribute values with scenario modifiers

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 traffic.using_snp:
    speed: speed
    car1: vehicle
    car2: vehicle


    do parallel(overlap:equal):
        car1.drive()
        car2.drive() with:
            speed(speed: 20kph, faster_than: car1)

Example: event declaration

OSC2 code: event 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)

scenario sut.scenario1:
    snow_depth: length


    event deep_snow is (snow_depth > 15cm)

Example: 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)


# Define an actor
actor my_car_group:
    average_distance: length
    number_of_cars: uint

Example: actor extension

OSC2 code: actor extension

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


# Extend an actor in a separate file
import "my_car_group.osc"

extend my_car_group:
    average_speed: speed


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

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

Example: scenario implementation

OSC2 code: scenario implementation

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: define test

OSC2 code: define test

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

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr" # specify map to use in this test

extend top.main:
    do traffic.two_phases()

Example: define a cut-in maneuver

OSC2 code: define a cut-in maneuver

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)


# The cut-in scenario

scenario sut.cut_in:
    car1: vehicle        # The other car
    side: av_side    # A side: left or right

    r: one_way_road with: keep(it.min_lanes >= 2)# at least two lanes

    do serial():
        get_ahead: parallel(duration:[1..5]s, overlap:equal): # get_ahead is a label
            sut.car.drive() with:
                speed(speed: [30..70]kph)
                along(r)
            car1.drive() with:
                position(distance: [5..100]m,
                    behind: sut.car, at: start)
                position(distance: [5..15]m,
                    ahead_of: sut.car, at: end)
                along(r)
        change_lane: parallel(duration:[2..5]s, overlap:equal): # change_lane is a label
            sut.car.drive() with:
                along(r)
            car1.drive() with:
                lane(side_of: sut.car, side: side, at: start)
                lane(same_as: sut.car, at: end)
                along(r)

Example: use cut_in() in two_cut_in()

OSC2 code: use cut_in() in two_cut_in()

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


# The cut-in scenario

scenario sut.cut_in:
    car1: vehicle        # The other car
    side: av_side    # A side: left or right

    r: one_way_road with: keep(it.min_lanes >= 2)

    do serial():
        get_ahead: parallel(duration:[1..5]s, overlap:equal): # get_ahead is a label
            sut.car.drive() with:
                speed(speed: [30..70]kph)
                along(r)
            car1.drive() with:
                position(distance: [5..100]m,
                     behind: sut.car, at: start)
                position(distance: [5..15]m,
                    ahead_of: sut.car, at: end)
                along(r)
        change_lane: parallel(duration:[2..5]s, overlap:equal): # change_lane is a label
            sut.car.drive() with:
                along(r)
            car1.drive() with:
                lane(side_of: sut.car, side: side, at: start)
                lane(same_as: sut.car, at: end)
                along(r)



scenario sut.two_cut_ins:
    do serial():
        c1: cut_in(side: left)        # c1 is a label
        c2: cut_in(side: right)       # c2 is a label
    with:
        keep(c1.car1.color != c2.car1.color)


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

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

Example: run cut_in() with concrete values

OSC2 code: run cut_in() with concrete values

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



# The cut-in scenario

scenario sut.cut_in:
    car1: vehicle        # The other car
    side: av_side    # A side: left or right

    r: one_way_road with: keep(it.min_lanes >= 2)

    do serial():
        get_ahead: parallel(duration:[1..5]s, overlap:equal): # get_ahead is a label
            sut.car.drive() with:
                speed(speed: [30..70]kph)
                along(r)
            car1.drive() with:
                position(distance: [5..100]m,
                     behind: sut.car, at: start)
                position(distance: [5..15]m,
                    ahead_of: sut.car, at: end)
                along(r)
        change_lane: parallel(duration:[2..5]s, overlap:equal): # change_lane is a label
            sut.car.drive() with:
                along(r)
            car1.drive() with:
                lane(side_of: sut.car, side: side, at: start)
                lane(same_as: sut.car, at: end)
                along(r)

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


# Run cut_in with concrete values
extend top.main:
    do sut.cut_in() with:
        keep(it.get_ahead.duration == 3s)
        keep(it.change_lane.duration == 4s)

Example: mix multiple scenarios

OSC2 code: mix multiple scenarios

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

# Mixing multiple scenarios

scenario sut.interceptor:
    car1: vehicle

scenario sut.interceptor_at_yield:
    do interceptor: sut.interceptor()

# The cut-in scenario

scenario sut.cut_in:
    car1: vehicle        # The other car
    side: av_side    # A side: left or right

    r: one_way_road with: keep(it.min_lanes >= 2)

    do serial():
        get_ahead: parallel(duration:[1..5]s, overlap:equal): # get_ahead is a label
            sut.car.drive() with:
                speed(speed: [30..70]kph)
                along(r)
            car1.drive() with:
                position(distance: [5..100]m,
                     behind: sut.car, at: start)
                position(distance: [5..15]m,
                    ahead_of: sut.car, at: end)
                along(r)
        change_lane: parallel(duration:[2..5]s, overlap:equal): # change_lane is a label
            sut.car.drive() with:
                along(r)
            car1.drive() with:
                lane(side_of: sut.car, side: side, at: start)
                lane(same_as: sut.car, at: end)
                along(r)


scenario sut.mix_dangers:
    weather: weather_type
    keep(weather != clear)

    do parallel(overlap:any):
        cut_in()
        interceptor_at_yield()
        environment.weather(kind: weather)


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

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

Example: declare the cut_in_and_slow() scenario

OSC2 code: declare the cut_in_and_slow() scenario

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

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



# declare cut_in_and_slow
scenario sut.cut_in_and_slow:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right


# cut_in_and_slow_imp.osc
extend sut.cut_in_and_slow:
    do serial():
        start_behind_sut: parallel(duration:[1..10]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                speed(speed: [30..200]kph)
                position(distance: [5..30]meter, behind: sut.car, measure_by: nearest, at: start)

        change_lane: parallel(duration:[1.5..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                l1: lane(side_of: sut.car, side: side, at: start)
                p1: position(time: [1..5]second, ahead_of: sut.car, measure_by: nearest, at: start)
                speed([30..200]kph, run_mode: best_effort)
                avoid_collisions(false)
                l2: lane(same_as: sut.car, track: projected, at: end)
                p2: position(time: [1..5]second, ahead_of: sut.car,
                        track: projected, measure_by: nearest, at: end)

        slow: parallel(duration:[3..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                keep_lane()
                change_speed([-20..-10]kph)

extend top.main:
    do sut.cut_in_and_slow()

Example: implement the cut_in_and_slow() scenario

OSC2 code: implement the cut_in_and_slow() 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.cut_in_and_slow()

# cut_in_and_slow
scenario sut.cut_in_and_slow:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right


# cut_in_and_slow_imp
extend sut.cut_in_and_slow:
    do serial():
        start_behind_sut: parallel(duration:[1..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                speed(speed: [30..200]kph)
                position(distance: [5..100]meter, behind: sut.car, at: start)

        change_lane: parallel(duration:[1.5..3]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                l1: lane(side_of: sut.car, side: side, at: start)
                p1: position(time: [0.5..1]second, ahead_of: sut.car, at: start)
                speed([30..200]kph, run_mode: best_effort)
                avoid_collisions(false)
                l2: lane(same_as: sut.car, track: projected, at: end)
                p2: position(time: [1.5..2]second, ahead_of: sut.car,
                        track: projected, at: end)

        slow: parallel(duration:[3..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                keep_lane()
                acceleration(acceleration:  \
                [car1.policy.get_min_acceleration()..car1.policy.get_min_acceleration()/2])

Example: define the cut_in() scenario in a separate file

OSC2 code: define the cut_in() scenario in a separate file

# ts_cut_in_and_slow

# import simulator interface
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

# cut_in_and_slow
scenario sut.cut_in_and_slow:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right


# cut_in_and_slow_imp





# cut_in.osc
scenario sut.cut_in:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right

    do serial():
        change_lane: parallel(duration:[1.5..3]second, overlap:equal):
            sut.car.drive() with:
                keep_lane()  # prevent sut from avoiding cut in
            car1.drive() with:
                l1: lane(side_of: sut.car, side: side, at: start)
                p1: position(time: [0.5..1]second, ahead_of: sut.car, at: start)
                speed([30..200]kph, run_mode: best_effort)
                avoid_collisions(false)
                l2: lane(same_as: sut.car, track: projected, at: end)
                p2: position(time: [1.5..2]second, ahead_of: sut.car,
                    track: projected, at: end)


extend sut.cut_in_and_slow:
    road: one_way_road
    do serial():
        start_behind_dut: parallel(duration:[1..5]second, overlap:equal):
            sut.car.drive() with:
                speed(speed: [30..200]kph)
                keep_lane()
                along(road)
            car1.drive() with:
                speed(speed: [30..200]kph)
                position(distance: [5..100]meter, behind: sut.car, at: start)
                l1: lane(side_of: sut.car, side: side)
                along(road)

        cut_in: cut_in(car1: car1, side: side)

        slow: parallel(duration:[3..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                keep_lane()
                acceleration(acceleration:
                [car1.policy.get_min_acceleration()..car1.policy.get_min_acceleration()/2])



# specify the map to use
extend test_config:
    set map = "$FTX_PACKAGES/maps/M67_FTX_highway_speed_variations.xodr"

# extend the entry-point scenario to activate the scenario
extend top.main:

    do cias: sut.cut_in_and_slow()

Example: import and invoke the cut_in() scenario

OSC2 code: import and invoke the cut_in() scenario

# ts_cut_in_and_slow

# import simulator interface
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"



# cut_in_and_slow_imp.osc
import "cut_in.osc"

# cut_in_and_slow
scenario sut.cut_in_and_slow:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right

extend sut.cut_in_and_slow:
    do serial():
        start_behind_dut: parallel(duration:[1..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                speed(speed: [30..200]kph)
                position(distance: [5..100]meter, behind: sut.car, at: start)

        cut_in: cut_in(car1: car1, side: side)

        slow: parallel(duration:[3..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                keep_lane()
                acceleration(acceleration:
                [car1.policy.get_min_acceleration()..car1.policy.get_min_acceleration()/2])




# specify the map to use
extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

# extend the entry-point scenario to activate the scenario
extend top.main:

    do cias: sut.cut_in_and_slow()

Example: define the coverage metrics

OSC2 code: define the coverage metrics

# ts_cut_in_and_slow

# import simulator interface
import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

# cut_in_and_slow
scenario sut.cut_in_and_slow:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right


# cut_in_and_slow_imp


# cut_in.osc

scenario sut.cut_in:
    car1: vehicle  # The "cut-in" car
    side: av_side  # The side of which car1 cuts in, left or right

    do serial():
        change_lane: parallel(duration:[1.5..3]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                l1: lane(side_of: sut.car, side: side, at: start)
                p1: position(time: [0.5..1]second, ahead_of: sut.car, at: start)
                speed([30..200]kph, run_mode: best_effort)
                avoid_collisions(false)
                l2: lane(same_as: sut.car, track: projected, at: end)
                p2: position(time: [1.5..2]second, ahead_of: sut.car,
                    track: projected, at: end)


extend sut.cut_in_and_slow:
    do serial():
        start_behind_dut: parallel(duration:[1..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                speed(speed: [30..200]kph)
                position(distance: [5..100]meter, behind: sut.car, at: start)

        cut_in: cut_in(car1: car1, side: side)

        slow: parallel(duration:[3..5]second, overlap:equal):
            sut.car.drive()
            car1.drive() with:
                keep_lane()
                acceleration(acceleration:
                [car1.policy.get_min_acceleration()..car1.policy.get_min_acceleration()/2])



# cut_in_cover
extend sut.cut_in:
    cover(side)
    # sample the same parameters at the start of change_lane phase
    var rel_d_change_lane_start:= sample(map.abs_distance_between_positions(
        sut.car.state.msp_pos.road_position,
        car1.state.msp_pos.road_position), @start) with:
        cover(rel_d_change_lane_start,
            text: "How ahead is car1 relative to dut at change_lane start (in centimeter)",
            unit: centimeter,
            range: [0..5000],
            every: 50)

    var dut_v_change_lane_start:= sample(sut.car.state.speed, @start) with:
        cover(dut_v_change_lane_start,
            text: "Speed of dut at change_lane start (in kph)",
            unit: kph,
            range: [10..200],
            every: 10)

    var rel_v_change_lane_start := sample(car1.state.speed - sut.car.state.speed,
     @start) with:
        cover(rel_v_change_lane_start,
            text: "How much faster is car1 than the sut at change_lane start (in m/sec)",
            unit: mps,
            range: [-53..53])

    # sample the same parameters at the end of change_lane phase
    var rel_d_change_lane_end:= sample(map.abs_distance_between_positions(
        sut.car.state.msp_pos.road_position,
        car1.state.msp_pos.road_position), @change_lane.end) with:
        cover(rel_d_change_lane_end,
            text: "How far ahead is car1 from dut at change_lane end (in cm)",
            unit: centimeter,
            range: [0..6000],
            every: 50)

    var dut_v_change_lane_end:= sample(sut.car.state.speed, @change_lane.end) with:
        cover(dut_v_change_lane_end,
            text: "Speed of dut at change_lane end (in kph)",
            unit: kph,
            range: [10..200],
            every: 10)

    var rel_v_change_lane_end := sample(car1.state.speed - sut.car.state.speed,
        @change_lane.end) with:
        cover(rel_v_change_lane_end,
            text: "How much is car1 than the sut at change_lane end (in m/sec)",
            unit: mps,
            range: [-53..53])


# specify the map to use
extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

# extend the entry-point scenario to activate the scenario
extend top.main:

    do cias: sut.cut_in_and_slow()