|
Disclaimer
This document is the copyrighted property of ASAM e.V. In alteration to the regular license terms, ASAM allows unrestricted distribution of this standard. §2 (1) of ASAM’s regular license terms is therefore substituted by the following clause: "The licensor grants everyone a basic, non-exclusive and unlimited license to use the standard ASAM OpenODD". |
1. Foreword
The Association for Standardization of Automation and Measuring Systems (ASAM) is a non-profit organization that promotes standardization for tool chains in automotive development and testing. Our members are international car manufacturers, suppliers, tool vendors, engineering service providers and research institutes. ASAM standards are developed in work groups, composed of experts from our member companies. Our standards enable easy exchange of data or tools within a tool chain. ASAM is the legal owner of these standards and responsible for their development, maintenance, distribution and marketing.
ASAM standards focus on defining data models, file formats, communication APIs, software component APIs, and communication protocols for the data exchange between research, development, and validation systems. ASAM standardization seeks to incorporate requirements from many different global viewpoints and produce an efficient interface.
2. Introduction
2.1. Overview
Safety is fundamental to the development of public trust and acceptance of Connected and Autonomous Vehicles (CAVs) and their on board Automated Driving Systems (ADSs) and to enable deployment of automated driving. Safety of CAVs has two aspects: safe design and safe use of the system. In order to ensure safe use of the system, it is important to convey the knowledge of the true capabilities and limitations of the ADSs to the users to prevent misuse of the systems.
In order to establish the true capabilities and limitations of an Automated Driving Systems (ADSs), we need to first define their Operational Design Domain. An ODD refers to the operating environment (road type, weather conditions, traffic conditions) in which a vehicle can drive safely. For example, for Low-Speed Automated Driving (LSAD) systems such as pods and shuttles, the ODD may include urban areas with predefined routes that include pedestrians and cyclists. On the other hand, for a motorway chauffeur system, an ODD may include a four-lane divided motorway and dry conditions only. The types of scenarios a vehicle may encounter will be a function of its defined ODD, making this fundamental to any safety evaluation and scenario identification.
- A more formal definition of ODD as defined by SAE J3016 (2018) states that "Operating conditions under which a given driving automation system or feature thereof is specifically designed to function, including, but not limited to, environmental, geographical, and time-of-day restrictions, and/or the requisite presence or absence of certain traffic or roadway characteristics". -
In order to enable stakeholders to share, compare and re-use ODD definitions, there is a need for standards to provide guidance to the stakeholders on both the attributes to be used for ODD definition and a format for defining the ODD using those attributes. BSI PAS 1883 (UK) provides a taxonomy for ODD. Additionally, ISO 34503 uses the taxonomy to provide a high-level definition format for ODD. While these standardization activities address the important needs of the industry, a gap still exists in the industry for an ODD definition format for simulation.
ASAM OpenODD is a representation of the abstract ODD specification in a more well-defined syntax and semantics which enables machines to interpret and perform the required analysis. Additionally, the ASAM OpenODD specification shall be measurable and verifiable for the attributes it specifies.
2.1.1. Motivation
An Operation Design Domain definition (ODD) shall be valid throughout the whole vehicle’s lifetime. The definition of an ODD is part of the safety concept of a vehicle. Depending on the current development step different information needs to be derived from such an overall ODD.
ASAM OpenODD focuses on a machine-readable format. The ODD must be represented so it can easily be used within simulation and other machine processed environments. The content of ASAM OpenODD will be derived from any abstract ODD, providing the information in a usable manner. For the purpose of using this ODD description for simulations and post-processing the format must fulfill the following requirements:
-
Searchable
-
Exchangeable
-
Extensible
-
Machine readable
-
Measurable and verifiable
-
Human readable
In the scenario based testing workflow ASAM OpenODD will play a very important role supporting the test description, defining the boundaries of what to test and achieving a good test coverage of the operational design domain and its borders.
| For more details on scenario based testing workflows, consult the Paper released by the ASAM Test Specification Study Group. |
Using the ASAM OpenODD specification will ensure that it is possible to statistically quantify:
-
exposure of certain attribute values of the ODD,
-
the performance of an CAV and its systems against the ODD,
-
the tightening or expansion of the ODD over time.
ASAM OpenODD will be compatible with the wider ASAM OpenX suite of standards (OpenDRIVE, OpenSCENARIO and OpenXOntology). Furthermore, ASAM OpenODD will be consistent with the ongoing ISO activities (e.g. AWI ISO 34503). Compatibility of ASAM OpenODD will be achieved during a harmonization phase before the beggining of the standardization project.
2.2. Normative and non-normative statements and deliverables
This specification uses a standard information structure. The following rules apply regarding normativity of sections:
-
Statements expressed as requirements, permissions, or prohibitions according to the use of modal verbs, as defined in Section Modal verbs, are normative.
-
UML diagrams from the ASAM OpenODD UML model are normative.
-
Rules for ASAM OpenODD data structures in "Rules" sections are normative.
-
XML examples and use case descriptions are non-normative.
2.3. Conventions
2.3.1. Units
Unless stated otherwise, all numeric values within this specification are in SI units, for example:
-
position/distance in [m]
-
angles in [rad]
-
time in [s]
-
speed in [m/s]
Geographic positions are stated in the unit defined by the spatial coordinate system, for example, in accordance with WGS 84 – EPSG 4326 [1].
Some data elements allow to explicitly state the unit of a given value. If the unit is not given or if there is no means to state the unit, SI units apply. The following units may be used in explicit assignments:
| Category | Description | Identifier |
|---|---|---|
distance |
meter |
m |
kilometer |
km |
|
feet |
ft |
|
land mile |
mile |
|
speed |
meters per second |
m/s |
miles per hour |
mph |
|
kilometers per hour |
km/h |
|
mass |
kilogram |
kg |
metric tons |
t |
|
slope |
percent |
% |
These optional units shall be used for purposes of signage and speed indication only. They shall not be used as general units, for example, to define road geometry, etc.
2.3.2. Modal verbs
To ensure compliance with the ASAM OpenODD standard, users need to be able to distinguish between mandatory requirements, recommendations, permissions, as well as possibilities and capabilities.
The following rules for using modal verbs apply:
| Provision | Verbal form |
|---|---|
Requirement |
shall |
Recommendation |
should |
Permission |
may |
Possibility and capability |
can |
Obligation and necessity |
must |
2.4. Understanding ODDs
2.4.1. What is a ODD Specification?
An ODD defines the operating conditions an ADS is designed to operate in. This includes all ranges of roads, environmental conditions, part of the dynamic elements (mainly the ego designated speed) and types of traffic participants within a macroscopic traffic during all allowed weather conditions and time-of-day restrictions. The ODD will specify the domain and its borders the ADS is designed to safely operate in or needs to be capable of handling. This opens up a multidimensional space that needs to be specified.
According to SAE J3016 an ODD is defined as follows:
Operating conditions under which a given driving automation system or feature thereof is specifically designed to function, including, but not limited to, environmental, geographical, and time-of-day restrictions, and/or the requisite presence or absence of certain traffic or roadway characteristics.
2.4.2. Operational Domain (OD) vs. Operational Design Domain (ODD )
A specific type of terminology misuse in practice is failing to distinguish between the real world and the ODD.
-
"ODD" refers to the intended ADS capability to handle operating conditions, and not the real world.
-
"Operational Domain (OD)" refers to what the world actually is, which might (in most cases will) differ from the ODD.
Thus, when the real world (OD) is outside the intended operational design environment (ODD), the vehicle has exited the ODD and is no longer in an environment it was designed to operate within. The difference between OD and ODD highlights the limitations of the ADS. Additionally, an automated driving system feature can have only one ODD. However, a vehicle can have multiple automated driving system features. Thus it is incorrect to say, for example, that a Level 4 highway feature has "multiple ODDs of day and night with fair weather" when what should be said is that the feature has "an ODD that includes both day and night in fair weather."
In all practical cases, an ODD definition will not be exhaustive enough to cover all attributes or occurrences in an OD. Therefore, it is essential to be able to define an ODD which is not only objective but which defines clear boundaries to enable ADSs to perform fallback manoeuvres to ensure safe operation.
2.4.3. Difference between ODD and Scenario
It is important to highlight that while ODDs and scenarios are related, they are not the same. As mentioned earlier, an ODD essentially defines the operating environment for which a system is designed. It may also be seen from the perspective of the end-user (e.g. city council authority) as the operating environment in which a system should be able to operate safely. It is essential that there is an overlap between the two perspectives of the ODD, manufacturer (or the system designer) and the end-user for ensuring the safe deployment of CAVs.
A scenario defines the behavior of various actors and entities in an ODD. Below the difference between scenario and ODD is highlighted graphically. [fig-simple-odr-odd] depicts a part of an ODD with single lane non-divided road which has passenger cars. Simple scenario with passenger cars depicts a scenario which illustrates the behavior of the vehicles in the ODD of [fig-simple-odr-odd]. In summary, once the behavior of the actors is defined in a part of an ODD, it becomes a scenario. This has no influence on the fact that a scenario is a stand alone entity regardless of the ODD definition and therefore can be defined independently
In Example ODD for the domain the graph on the left side represents the ontology or taxonomy the ODD specification can chose attributes from.
Figure 6a highlights the ODD attributes as per BSI PAS 1883. If an ADS has the ODD defined as Figure 6b, then the ODD comprises of a "divided single lane" road with a "T-junction" (scenery attributes of ODD). Furthermore, from the dynamic elements attributes, ODD comprises of "passenger cars". The difference between the ODD definition and the scenario definition is that the scenario definition also includes the behavior description of the actors, i.e. passenger cars.
2.4.4. The Scope and Usage of the ASAM OpenODD Language
Being a language for defining or describing ODDs is the main purpose of the new ASAM OpenODD language, but obviously there are many more activities in the domain of automated driving system concept, design, analysis and validation that can profit from a formalized language for ODDs. The proposed ASAM OpenODD language has been designed with many of these use cases in mind, and in the present concept phase there is no reason to consider the list as final and exhaustive. Nevertheless, usability for many stakeholders, including persons who are not specialists for complex computer languages, is a key concern for ASAM OpenODD development and entails the need to keep the core language simple and not to overburden it with lots of complex language constructs just to cover each and every potential use case. The solution chosen consists of a core language that is sufficient for the primary purpose of ASAM OpenODD, which is to describe an ODD. Around this core language, many extensions are grouped as shown in the ODD Definition and surrounding use cases. Also this list does not have to be exhaustive, according to its requirements, the ASAM OpenODD language will be designed with extension mechanisms so that future extensions can still be added. As shown in the picture, even the core part of defining ODDs makes references to external work: the ontology, on which each ODD description is based, can and should be referenced from external sources (in particular OpenXOntology) and specified in their respective standardized language.
The use of all extensions (grouped around the core language in the figure) is optional, but prepared in the structure of the language (including the ability to create "bindings" of functions to 3rd party implemented functions in any language like Python or C). For the concept phase, the following list of extensions is proposed, which could technically be released as "standard libraries" such as the standard libraries of programming languages like C form a basic ecosystem, on which users of the core language can rely.
The following extensions are proposed:
| TODO add that not all chapter’s are fully flushed out due to the missing working group |
2.4.5. Completeness of an ODD
Since the information of the ODD is involved in the design, testing, release and so on, the completeness of the provided information becomes relevant. However, completeness should not be understood in an absolute sense, which means that no extra information can occur if a specific procedure is conducted. This is because of the open context, which makes it impossible to specify each and every aspect beforehand. Therefore, completeness is understood in a relative sense that requires us to define a reference against which the completeness of an ODD model can be measured. For the provision of such a reference, internal references as well as external sources can be used as a structure.
The completeness of the ODD results from the two aspects. This includes 1) completeness of the underlying ontology, and 2) completeness of the ODD description. To give a quick overview of the relation between the two, an ODD description language is a language format that has the capability of assigning the relevant ODD attributes to be either inside/outside its intended ODD boundary. However, these ODD attributes originate from an external taxonomy or ontology. Only by combining the ontology and an ODD description language can an ODD be produced. The BSI PAS 1883 on the taxonomy for the ODD of ADSs comments that from the perspective of the attributes/taxonomy, the ODD attributes list can never be exhaustive. This indicates that there is no 'complete' sense in terms of the underlying ontology that is used, which also resonates with one of the core language features that will be introduced in a later chapter (the extensibility of the underlying ontology). On the other hand, from the ODD language perspective, every piece of an ODD description must be complete, i.e, all the attributes from the underlying ontology need to be assigned and a binary (non fuzzy) boundary can be introduced across all the ODD attributes. To sum up, the underlying ontology can never be exhaustive, but the ODD description format needs to ensure every ODD is complete against the underlying ontology, and the permissive and restrictive concepts help to ensure completeness.
2.5. Use cases for ASAM OpenODD
In this chapter the use cases for the ASAM OpenODD are defined. In the development process the users of ASAM OpenODD were defined beforehand and the uses cases defined according to the users.
2.5.1. Users for ASAM OpenODD
Who will use and create the ODD and therefore use the OpenODD
-
The infrastructure operator includes Regulatory, Procurement, Safety Operator
2.5.2. User Stories
|
|
OpenODD Data Scientist Use-Cases, extending the ontology (i.e. need to support ontology by reference)
|
|
|
|
|
|
3. Relations to other standards
| Name of the Standard | Description |
|---|---|
ASAM OpenSCENARIO |
Description and exchange format for scenario descriptions |
ASAM OpenXOntology |
defines an ontology (and set of attributes) for the ASAM OpenX Domain |
ASAM OpenLABEL |
defines a standardized format for multi-sensor data labelling and scenario tagging. The format is based on a JSON schema |
ASAM OpenDRIVE |
standardized exchange format for the description of road-networks and the static entities on and along the road. ASAM OpenDRIVE is based on a xsd schema, using xml as an format |
ASAM OpenCRG |
a binary format to define road elevation or friction profiles |
ASAM ODS |
allows to store information in a database context and exchange it between tools. Based on a standardized meta-model (the base model) application-domain specific data models (the application models) may be defined. This may lead to consistent data sets e.g. combining ODDs with scenario based test definitions and corresponding test results for evaluations and long term storage. |
3.1. Positioning of ASAM OpenODD within ASAM activities
ASAM OpenODD is part of the ASAM simulation standards that focus on simulation data for the automotive environment. Next to ASAM OpenODD, ASAM provides other standards for the simulation domain, like ASAM OpenSCENARIO and ASAM OpenDRIVE.
ASAM OpenODD aims to describe the intended operating conditions (domain) an automated driving system is designed for. Part of the domain consists of the characteristics of the road network which can be derived from ASAM OpenDRIVE. A very simple road network is shown in Simple roadnetwork defined in ASAM OpenDRIVE. In this road network three incoming roads lead into a t-junction. This t-junction is made up out of several connecting roads.
As the road network only covers parts of the static elements of the driving environment additional information source may be needed (dynamic elements). The automated driving system also needs a specification of what kind of traffic participants it needs to be capable of handling. These dynamic elements and their behavior can be represented using ASAM OpenSCENARIO. A simple scenario with 4 passenger cars is shown in Simple scenario defined in ASAM OpenSCENARIO.
When analyzing the above two examples a few attributes of the ODD can already be identified. The automated driving system shall be designed to operate in:
-
divided single lane roads, with right hand traffic
-
a t-junction without traffic lights
-
passenger cars
This is shown in Example ODD for the domain
In addition to ASAM OpenSCENARIO and ASAM OpenDRIVE, ASAM OpenODD is also closely linked with the ASAM OpenLABEL standard, especially on the scenario tagging aspect. Figure below illustrates one example use case of the scenario tagging within ASAM OpenLABEL, it can be seen that each scenario is associated with corresponding tags from a bucket of tags. Based on such information, scenarios can be searched easily within the database. The link between ASAM OpenODD and the ASAM OpenLABEL scenario tagging aspect is that ODD tags form a major part of this 'bucket of tags'. The ASAM OpenODD attributes are closely aligned with the ASAM OpenLABEL tagging model. By utilizing such common properties, organizing and searching of scenarios and ODDs, and their dependencies can be effectively achieved.
3.2. References to other standards
| Name of the Standard | Description |
|---|---|
ISO 34503 (in development) |
Provides a taxonomy for operational design domain for automated driving systems, along with a high level definition format for use by regulators and non-coders. |
BSI PAS 1883 |
Provides a taxonomy that can be used to ODDs for automated driving systems |
SAE AVSC00002202004 AVSC Best Practice for Describing an Operational Design Domain: Conceptual Framework and Lexicon |
Aims to establish a best practice for Operational Design Domain description, establishing commonly defined terms and recommending a framework in which they can be applied. |
SAE J3016 (2021) / ISO 22736 |
Defines the term ODD and its use for classifying levels of autonomy for automated driving systems |
ISO 21448 SOTIF |
Provides guidance on defining the safety of an ADS system or feature for its intended functionality. |
ISO TS 5083 (in development) |
Provides guidance on safety of an ADS system (design and verification stage). |
4. Language and Format for ASAM OpenODD
The language and format chapter forms the core language concepts of the OpenODD. Every language development was made against a pre-identified requirement which was identified during the initial phase of the project. The content in this section will provide an overview of the overall development process, followed by the identified requirements clusters, and furthermore examples were provided for each of the requirements. These examples contain two different syntax proposals and the query semantics (where applicable). Thirteen different requirement clusters in total have been identified, which define the scope of the OpenODD format:
-
readability
-
composability
-
conditional statement
-
extensibility of ontology
-
binary boundary
-
class/metric/data type/ units
-
expression/abstraction
-
extensibility by function
-
operators
-
permissive/restrictive
-
language extensions(probability
-
uncertainty)
-
integration with scenario-based testing workflow.
From the thirteen requirement cluster examples, both the semantic and syntactic aspects of the language are covered.
The chapter includes:
-
Overview of the language concept development process
-
Requirements collection and requirement clusters creation
-
Main language concepts
-
Main language concept (extensibility of ontology) and extended language concepts (metrics, probability&uncertainty and extensibility by function) centered around the extensibility nature of the language
-
Integration with scenario-based testing workflow
4.1. Example syntax representation
During the concept project several syntax approached evolved and were proposed. The project decided to move forward with two of these proposal:
-
Syntax 1 is aligned with OpenSCENARIO 2
-
Syntax 2 aligns with the query semantics approach which evolved during the OpenODD concept project phase
4.1.1. Introduction into syntax 1
Modelling assumptions and principles for representing and using ODDs using OSC 2.0 language:
OpenSCENARIO 2.0 is an object oriented, aspect oriented, declarative, domain specific programming language. As such, it offers the full feature set of programming languages, in terms of operators, types and variables. It includes methods, structures, units, constraints specification and more. The examples are using OpenSCENARIO 2.0 syntax and constructs, with some assumption on a potential way to include and refer to ODD specification, in the same language in which scenarios are written, and using the same types, units and entities.
ODD definition:
We assume the full ODD ontology is defined in a type called ODD.
Sets of values are defined as enumerated types, for example:
type rain_type: [none, light, moderate, heavy]
type wind_type: [calm, moderate, storm]
type road_type: [city_road, motorway]
Sub-hierarchies are defined as structs, for example:
struct weather_type: odd_struct:
rain: rain_type
wind: wind_type
The full ODD is defined by hierarchical composition:
struct ODD: odd_struct:
weather: weather_type
road: road_type
and so on…
odd_struct
ODD types are declared using a subtype of OpenSCENARIO struct called odd_struct. odd_struct fields may represent:
-
a physical value or range like speed
-
an enumerated value representing some classification, like light_rain
-
a Boolean flag like has_guardrail
-
a numeric value or range like number_of_lanes
-
a sub odd_struct representing a hierarchy
The current ODD is captured by top.odd which is an instance of odd_struct
constraints
Constraints are added to odd_struct, representing the limitations imposed by the ODD specification. They should be set-oriented. Only rarely does constraining to a specific value makes sense in ODD context. The synthetic constraint all_default_values() restricts all unconstrained fields to their default values, , implying that any restrictions on them will lead to contradiction. This is used when defining a restrictive ODD.
OpenSCENARIO 2.0 supports importing of packages (source files). Once imported, the types defined in these packages are available. This is the expected method to import either the ODD ontology/taxonomy , or ODD definitions.
Binding method to external library
The binding of a function defined in an external library to a method in OSC2.0 is done as follows:
def <method-name>(<arguments>):<returned-type) is external.cpp("function-name", "shared-object-name")
Once defined the method can be called to invoke the associated library function.
4.1.2. Introduction to syntax 2
The semantics of an ODD specification are defined as a mapping of all possible variable value assignments (continuous, integers, binary or enumerated type) to a True/False determination. Intuitively, it is equivalent to an SQL query selecting of all possible situations whereby the "WHERE" condition is provided by the ODD specifications: Situation returned by such query are included in the ODD; all other situations are excluded.
Each statement must start at a new line, but it may span multiple lines. When a statement spans multiple lines, the 2nd and subsequent lines must be indented.
Each statement must start with one of the following keywords: INCLUDE, SUITABLE, UNSUITABLE, DETERMINE, ADDCOND,MEASURE. In addition, the TAG keyword can be used towards the end of certain station as a packaging mechanism to bundle a set of ODD attributes and form under a new ODD name. The keywords defined are not yet completed and need to be extended for cover all required functionalities.
Each statement is associated with specific syntax rules:
-
INCLUDE- Include statements start with the keyword "INCLUDE" followed by a file name. Included files may be an ontology file or other ODD specifications, and there is no restriction with regard to the depth (or breadth) of the include tree. -
SUITABLE/UNSUITABLE- these two keywords are used at the start of the corresponding statements to indicate the permissive/restrictive nature applied to each individual statement. They have the following patterns (parenthesis denote optional keywords):suitable conditionSUITABLE <concept> (EXCEPT) WHEN <condition>
unsuitable conditionUNSUITABLE <concept> (EXCEPT) WHEN <condition>
-
ADDCOND- it is used to add custom extension to an existing domain model or ontology, for example if user wants to add 'my_special_T-junction' to an existing ODD attribute 'T-junction',ADDCONDcan be used. The standard format for usingADDCONDis:ADDCOND<new_condition>TO<concept>(AS<relationship>) whereby:-
<concept>is defined by a previous statement, either in the same file or in an included file. -
<relationship>defaults to "child-of" if the expression is omitted; otherwise, a specific relationship is added to the concept graph, this part is optional. Example: user would like to add 'my_special_T-junction' under the T-junction class, the format would be:
-
ADDCOND my_special_T-junction TO T-junction
-
DETERMINE- this keyword is used to construct new classes/or to assign existing classes using a set of values. For example, is user wants to specify that 'my_special_rain' is when both the rainfall rate greater than 5mm/hr and the droplet size greater than 1mm diameter, the keywordDETERMINEcan be used to perform such assignment (see in the example below). The format follows the structure:DETERMINE<concept>WHEN<expression>whereby the<expression>is an and-or-tree converting continuous variables/metric values to True/False values.
For example:define a constraint with a given rangeDETERMINE rain_heavy WHEN (rain_rate >5mm/hr) AND (droplet_size >1mm)
-
MEASURE- this is used to assign measuring unit and data type to an ODD attributes. For example, to assign mm/hr as a measuring unit for rainfall rate, while the datatype is float, such operation can be achieved by using this keyword. The "MEASURE" statement follows the format as below :-
MEASURE <symbol> TYPE numeric | enumIf TYPE is "numeric" we have the following additional component to this statement:MEASURE <symbol> TYPE numeric UNITS <unit_symbol> [RANGE <min>,<max>] [DEFAULT <value>]
-
For the example listed above, the MEASURE statement would be
+
MEASURE rainfall TYPE float UNITS mm/hr
-
TAG-TAGis used to package a selected numbers of parameters and provide them with a new ODD name. For example if user need to combine ODD1 and ODD2 to form a new ODD3, this keyword can be used. It follows the format below:<conditions> TAG <new_ODD_name>, where the conditions is the inclusion or exclusion. An example is shown below:SUITABLE ODD1 AND ODD2 TAG ODD3
4.2. Overview
This chapter focuses on the format of the OpenODD language. As illustrated earlier, the OpenODD language needs to satisfy various requirements from different target users. Such requirements will form the foundation of the language development, and will create a coherent storyline throughout this chapter.
To understand how this chapter is structured, it is important to first understand the overall development process the work package took during the project. In the early stage of the development, this list of requirements went through an expansion followed by a contraction phase. The expansion part built on top the identified use cases, and called for a further gathering of additional relevant requirements within the working group, this resulted in an extended requirement list. The group then evaluated the relevance of each submitted requirements, and provided necessary examples. The contraction part performed a clustering exercise on this extended list, many similar requirements were grouped together to form a 'requirement cluster', whose definition is the union of all its sub-requirements. Upon obtaining a list of requirement clusters, language concepts centred around each cluster were developed and proposed. Due to the nature of a concept project, the group decided to accept all the relevant proposals and suggestions (providing that the same concept proposal covers all the clusters). It will then be the responsibility of the standardization phase to consider the pros and cons of each concept and arrive at an unified concept. In addition to the language concept proposal, the group also utilized a more semantic-centred approach to illustrate each cluster, this is based on a neutral concept of query semantics, which is represented in syntax 2.
With the overall workflow introduced, readers should find the chapter structure easy to follow.
Section 4.2.1 provides the background and reference to the extended requirement list, the list also indicates group members' comments and those requirement entries that the group decided to be irrelevant.
Section 4.2.1 then introduces an overview of the requirement clusters together with their definitions which resulted from the extended requirement list.
Section 4.3 onwards provides detailed content associated with each of the clusters.
Such content includes:
-
a detailed definition of the cluster,
-
example challenge(s) the group proposed that can represent the cluster,
-
how the challenges can be tackled using the OSC2.0 language and query semantic,
-
how such challenge(s) can be tackled with different proposed and developed syntax.
By reading this chapter, readers will gain understanding of the scope of the language concept, the details of each requirements, and the approaches/proposals.
4.3. Requirements for ASAM OpenODD
4.3.1. Collected requirements list
During the runtime of the project the project group collected requirements, the requirements are clusters into categories. In total the categories are as follows
syntax |
rules of writing, Format |
semantics |
how to interpret the written |
process |
how to integrate and/or use the written |
The link above leads to the extended list of requirements which form the foundation of future OpenODD language & format development work. Please note that within this list, project members have voted that requirements 60, 56a, 56b, 54, 62, 61, 37 will not be considered for the first draft of the OpenODD Format.
4.3.2. Requirement Clusters Overview
The Requirements are being clustered in the following clusters
Nr. |
Cluster |
Description |
Human readability |
ODD language needs to be intended to be used by various stakeholders, and it will be used as input to testing and analysis as well as specification, communications, analysis and debugging. |
|
Machine readability and query |
The language needs to be machine readable, can be parsed using any text parsers, should enable queries for attributes of the ODD. UTF8 Test using DSL,XML,YAML,others. |
|
Composability |
The language shall support combining/re-using multiple ODD definitions into a new, wider ODD, and it shall provide the ability to create a named subset of ODD attributes |
|
Parameterization and Templating |
In order to enable flexibility in definition, and flexibility in usage for testing and definitions, as well as the ability to supply templates for ODD definitions for various usages , the language should enable a parametrization mechanism, where names are replacing values, and are resolve toward actual usage time. |
|
Conditional statement |
Language specification needs to support conditional statement or reduced ODD. This can be tackled by imposing constraints on the full operational range of specific attributes. |
|
Extensibility of Ontology |
The language shall support the addition of new attributes and values that are not in the original ontology. It shall support the establishment of standard libraries, e.g. PAS 1883. |
|
Binary boundary |
The language shall map every situation into binary in/out of the ODD, convert 'uncertain' or 'fuzzy' situation into binary. |
|
Class metric / datatype / units |
|
|
Probability / Uncertainty / risk |
The language shall support qualifiers to represent uncertainty,probability and risk as optional element |
|
Class Hierarchy / expressiveness / abstraction |
The language format needs to be able to express the class hierarchy provided by the attribute group (WP01), it needs to support inheritance, be consistent with the class categorises (keywords), data type and units. It shall support abstract ODD definitions by choosing different hierarchical levels. |
|
Extensibility by function |
The language shall be extensible by internal or external functions. |
|
Operators |
The language shall use a set of mathematical and logical operators, such as +, -, and, or, >, <, etc |
|
Permissive / Restrictive |
The language should take a mixed permissive and restrictive approach to its statements of what is inside the ODD. |
|
Integration in scenario based testing workflow |
The language shall supply the ability to refer to ODD definition from scenario definition, interpretable to create a full test description , and can be used for different purposes (such as requirements, checking, success criteria or testing) |
|
Compatible with OpenX Standards |
The language shall be compatible with other OpenX standards and ASAM ODS, share a common domain model. |
4.4. Concepts for the language and format of ASAM OpenODD
Of the 15 requirement clusters, some of them can be bundled together due to similar nature. Instead of mechanically introduce them one by one, the following sections will be divided into three main parts: section 4.3 contains the first group of clusters where little similarity can be drawn between them, in addition, the concept of mandatory and optional attributes will also be covered in section 4.3; section 4.4 contains those clusters with extensibility property, this includes those belong to the core language concepts (i.e, extension by function, extensibility of ontology), and also those outside the core language concepts (i.e, metrics and probability); section 4.5 will introduce the integration with the scenario-based testing workflow.
4.4.1. Mandatory vs optional Attributes
The role of mandatory and optional attributes can be illustrated in combination of another key language feature (permissive/restrictive, which will be introduced in Permissive and restrictive definition). To briefly introduce, permissive means everything that is not explicitly describe in the ODD will be permitted, whereas restrictive corresponds to hte opposite. Now given the following ontology
If a blank ODD is defined in permissive mode, all the above attributes are allowed, if the blank ODD is defined in the mode restrictive, none of the above attributes would be allowed. This means that the only required attributes of an ODD defined using ASAM OpenODD are the global permissive/restrictive mode, and the reference to the underlying ontology. However, although not mandatory in nature, in some cases the attributes which can be associated with numerical values are also recommended to be specified. In the above example, the lane dimension is one such example. Let us imagine an ODD with such an ontology and a global permissive mode, this means the system can handle any lane dimensions that are listed in the ontology. While this could be true it is unlikely an ADS with a conventional vehicle size can handle extreme narrow lanes such as 1.50m.
4.4.2. Human and machine readability
ODD specifications are intended to be shared across wide range of stakeholders such as regulators and test engineers, it would be used as input to testing and analysis, but at the same time to be used by humans for purposes of specification, communications, analysis and debugging of systems under development. This requires ODD specification to be understandable to both technical and non-technical users. In the meantime, ODD specifications should enable machine readability for purposes such as runtime ODD coverage checking, comparisons between multiple ODDs. The language is intended to serve as input to computer programs, that should be able to parse, analyze , query and interpret the ODD information. In particular, query has been identified as an important requirement within the project group. Query could be performed between a traffic situation (corresponding to the concept of OD mentioned in the introduction) and the corresponding ODD specification utilizing an ontological approach.
Example use case:
An example ODD states that motorway is only suitable when there is no rain, up slope is not suitable as the vertical geometry.
Example representations:
-
Syntax 1:
keep(road_type == motorway => odd_5.weather.rain == none) keep(geometry.vertical != up_slope)
-
Syntax 2:
SUITABLE Motorway EXCEPT WHEN Rain UNSUITABLE Up_slope
4.4.3. Composability
The ASAM OpenODD language format should be composable, (i.e., combine ODD definitions into a new, wider one or use inheritance mechanism). In addition, the ability to re-use a defined section of an ODD should also be possible, by providing the ability to create a named subset of ODD attributes that can be defined together. Unions and intersections are examples of composing two ODDs, in addition the negation of ODDs can also be composed with other ODDs. When selecting subclasses from a parent class, the dot operator can be used such that if b is a sub-class of a, then a.b will point towards the b subclass, such convention can be seen in both syntax examples below. From a metric perspective, the language shall allow building new metrics out of existing metrics, functions and operators. This will be covered in the extensibility section.
The ability of being composable will also enable comparison of ODDs and identfiying contradicting specifications in the ODD. This can be very helpful when comparing a vehicle ODD to a City ODD, checking wether the car is able to operate safely in the streets of the city.
In the following abstract example the underlying meaning of of composing ODDs is illustrated. As can be seen that the first tree of attributes (first ODD) differs from the second tree, by composing these two together the third tree (ODD) is obtained, which is the union of the two. Please pay attention to the conditions that the speed for highway and for urban roads are separate (these are inherited from the individual ODDs and are not mixed during the composing process).
In the following abstract example the concept of comparing ODDs is illustrated. The mentioned "City ODD" can be seen as requirements towards the capability of the ADS. ADS ODD will be the designed capability of the vehicle. By comparing the two ODD specifications the suitability of the ADS towards the City requirements can be established.
Result:
The City ODD spedifies that any vehicle there (if going in automated mode) shall expect and be capable of handling
other vehicles moving with up to 60kph
while the ODD specification of the automated vehicle states under development states that its own maximum speed is 50kph. This alone is not a problem for operating the vehicle in the city (ego vehicle speed capability and traffic speed capability are two different things); it is sufficient that the vehicle can cope with traffic up to 60 kph, even if it cannot reach that speed itself.
Be aware that case would be different if there were constraints on the achievable speed of our vehicle, for instance related to a highway settings, where in some countries traffic regulations require that only motor vehicles with a nominal max speed of at least 60kph are allowed to be present; then, a vehicle with a technical max speed of only 50kph would be explicitly forbidden to enter that highway.
But there are more differences between our vehicle’s ODD and the city ODD:
-
The vehicle can only handle up to
medium traffic density. but the city’s ODD specifies that there can behigh traffic density. -
The vehicle’s ODD specification states that is not capable of handling
cyclists, where the city only states thatlorriesare not to be expected - so cyclists can occur. -
In terms of weather, the gap is that the vehicle can not operate in
fogandsnowwhich is according to the city ODD is to be expected.
As a result it can be concluded that the specified vehicle is not fully capable of operating in the given ODD of the city, and thus is not allowed to enter the city on automated driving (or, respectively, allow the human user to switch on the automated driving function while running in that city).
Note: In the section on queries there are more usage examples of such comparisons between a vehicle’s ODD and other ODDs, roadmaps or scenario sets.
Example use case: Compare and Combine
Given an ODD_1 which specifies that motorway is not suitable without restriction on the remaining classes on the ODD attribute hierarchy. Given another three ODDs (ODD_2, ODD_3, ODD_4) which specify wind conditions, rainfall condition and snowfall condition. The goal is to:
-
construct a weather ODD (ODD_5) by combining ODD_2, ODD_3 and ODD_4
-
construct a combined ODD (ODD_6), which takes the motorway ODD and weather ODD.
-
in addition, illustrate how to obtain the intersection, union and difference between two ODDs
-
Example syntax:
-
Syntax 1:
# ODDs mentioned in challenge: odd1: ODD: keep(road != motorway) odd2: ODD: keep(weather.wind != storm) odd3: ODD: keep(weather.rain in [none, light]) odd4: ODD: keep(weather.snow == none) odd5: ODD: # feature selection keep(weather.wind == odd2.weather.wind and weather.rain == odd3.weather.rain and weather.snow == odd4.weather.snow) # Since odd2, 3, 4 are orthogonal ( no overlap ) we could also create a union: odd5_1: ODD: # union keep(weather == union(odd2.weather, odd3.weather, odd4.weather) odd6: ODD: keep(road == odd1.road) keep(weather == odd5.weather) # recursive equivalence -
Syntax 2:
# For combining ODD1 and ODD2 into ODD3, various options depending on the combination operation: INCLUDE example_ontology # this contains rain_type, wind_type, road_type, geometry, weather_type ADDCOND [none, light, moderate, heavy] TO rain_type ADDCOND [calm, moderate, storm] TO wind_type ADDCOND [city_road, motorway] TO road_type # ODD ontology modeled as a hierarchical composition of odd_structs ADDCOND [rain_type, wind_type] TO weather_type SUITABLE motorway EXCEPT WHEN rain UNSUITABLE geometry WHEN up_slope # ODDs mentioned in challenge: UNSUITABLE road_type WHEN motorway TAG ODD1 UNSUITABLE weather_type WHEN storm TAG ODD2 SUITABLE rain_type WHEN none OR light TAG ODD3 UNSUITABLE weather_type WHEN snow TAG ODD4 SUITABLE * WHEN ODD2 AND ODD3 AND ODD4 TAG ODD5 SUITABLE * WHEN ODD5 AND ODD1 TAG ODD6 # In addition, below illustrate different composabilities # Intersection: SUITABLE * WHEN ODD1 AND ODD2 TAG ODD3 # Union: SUITABLE * WHEN ODD1 OR ODD2 TAG ODD3 # Difference ODD1-ODD2: SUITABLE * WHEN ODD1 AND NOT(ODD2) TAG ODD3
-
-
Example use case: selective combination
Import a sample ODD as ODD1 which constraints on both road type and weather. Import another ODD (ODD2), construct a new ODD (ODD3) that contains the weather part of ODD1 and the whole of ODD2.
Example syntax:
-
Syntax 1:
import odd_lib/ODD1.osc-lib # declares ODD1 import odd_lib/ODD2.osc-lib # declares ODD2 odd1: ODD1 # as imported odd2: ODD2 # as imported odd3: ODD keep(me.* == odd2.*) # all features equal to odd2 keep(weather == odd1.weather) #select the weather sub-hierarchy -
Syntax 2:
# It is important to differentiate ODD and ontology, within the statement # attribute without namespaces can be treated as coming from the ontology. # We could use namespaces for include multiple ontologies. INCLUDE PAS_1883.owl INCLUDE sample.odd AS ODD1 INCLUDE ODD2 SUITABLE ODD1.weather AND ODD2 TAG ODD3
| Combining ASAM OpenODD files should not allow inconsistencies in the combined ODD description. Checkers and validators should be implemented in the toolchain, to avoid any inconsistencies. |
4.4.4. Parameterization and Variable definition
In order to enable flexibility in definition, flexibility in usage for testing as well as the ability to supply templates for ODDs, the language should enable a parametrization mechanism, where actual values are replaced by variable names, and are parameterized during actual usage time.
Example use case: Variable usage
Example on how to use variable top_speed_limit in ASAM OpenODD
Example syntax:
-
Syntax 1:
keep (speed < top_speed_limit) # where the value of top_speed_limit is undefined, and will be defined once this statement is actually being instantiated or used
-
Syntax 2:
DETERMINE safe_speed WHEN speed < top_speed_limit SUITABLE * WHEN safe_speed
Example use case: Variable definition
Example on how to use variable rain of type enum in ASAM OpenODD, the actual value of the enumerations can be defined during usage
Example syntax:
-
Syntax 1:
type rain_type: [none, light, moderate, heavy]
-
Syntax 2
# define the constraint for rain, a constraint will either be True or False ENUM rain VALUES {no: WHEN mNoRain, low: WHEN mLowRain, medium: WHEN mMediumRain, heavy: WHEN mHeavyRain};
4.4.5. Conditional statement
Language specification needs to support conditional statement or reduced ODD. This can be tackled by imposing constraints on the full operational range of specific attributes.
When defining an ODD for a vehicle or a town, it might be necessary to define constraints according to certain conditions. This might be due to environmental conditions that degrade the capability of the vehicle or geographic specific conditions that have an impact on defined constraints.
Example use case: basic constraint definition
Examples showing how basic constraints are handled.
Example representations:
-
Syntax 1
odd1: ODD: keep(weather.rain in [heavy] => speed in [0..60]kph) keep(weather.rain not in [none, light] => road != motorway) -
Syntax 2
SUITABLE rain.heavy WHEN speed < 60 UNSUITABLE Motorway EXCEPT WHEN rain.none OR rain.light
Example use case: add constraint definition
Adding constraint to an existing constraint
Example representations:
-
Syntax 1
odd1: ODD: keep(speed in [0..80]kph) keep(weather.fog == heavy_fog => speed in [0..40]kph) -
Syntax 2
adding an additional Condition in Syntax 2SUITABLE speed > 10 EXCEPT WHEN rain.heavy SUITABLE rain.heavy WHEN (speed < 60 AND speed > 10)
Example use case: Apply basic constraints
The velocity in which an ADS system is operating is defined to be between 0 and 80kph. However, in the case of the a heavy fog ( assuming heavy fog is well defined ) , the ADS system is constrained to operate in velocity range of 0 to 40kph.
Example representations:
-
Syntax 1:
struct any_odd: max_speed: speed weather: odd_weather keep(max_speed < 80 kph) # restricted unconditionally # in case of fog, restrict further: keep(weather == heavy_fog => (max_speed <= 40 kph)) -
Syntax 2:
DETERMINE speed_high WHEN speed (> 40 AND =< 80) DETERMINE speed_low WHEN speed (=< 40) # MEASURE for specifying unit can also be combined with DETERMINE MEASURE speed UNITS kph UNSUITABLE speed_high WHEN heavy_fog SUITABLE speed_safe AND speed_low EXCEPT WHEN heavy_fog
Example use:
Given an ODD hierarchical tree, we would like to express that Motorway is only suitable when there is no Rain (conditional ODD statement),
within the Geometry, Up-Slope is not suitable, all Weather conditions are suitable.
Example representations:
-
Syntax 1
odd1: ODD: keep(weather.rain != none => road != motorway)# no motorway in rain keep(geometry.vertical != up_slope) -
Syntax 2:
SUITABLE Motorway EXCEPT WHEN Rain SUITABLE Vertical_geometry EXCEPT WHEN Up_slope
4.4.6. Binary boundaries
Any ODD definition requires the ability to have binary decision on any constraint, specified in the ODD.
The language will define the boundaries of the ODD specification. The language shall allow the mapping of every ODD terminal element into either inside or outside of the ODD in a binary manner by any external processor. This results in an ODD representation which can be evaluated to a set of TRUE/FALSE ODD terminal statements.
From a mathematical point of view such a representation relates to the ordered binary decision diagrams (OBDDs). From a programming point of view the OBDDs can be handled through boolean logical programming that allows to efficiently apply to OBDDs many logical operations (like conjunction, disjunction and negation) promoting composability of the language
Imposing restrictions to the possible combinations of ODD elements (concurrent evaluation of specific ODD elements to TRUE) can be achieved through conditional statements
In the envisioned (declarative) ODD domain specific language an ODD definition will be a collection of statements. This can be achieved by introducing to the language the following type of statement
propositional constraint statements:
A statement specifying a propositional constraint, using a logical expression over previously defined variables,
which can be evaluated using "truth tables", i.e. each ODD sub-statement as well as any composite ODD statement can be evaluated to either TRUE or FALSE.
The semantics of propositional constraint statements define the mapping of every possible combination of values for its input expression statements to a True/False value.
Propositional constraint statements_statements may be defined over other constraint statements.
Example use cases:
A road is considered unsafe for the automated driving system, if there is heavy or medium rain.
Example representations:
-
Syntax 1
keep(rain not in [medium, heavy])
-
Syntax 2:
SUITABLE rain EXCEPT WHEN medium OR heavy
4.4.7. Operators
linked to requirement cluster [CL12]
The operators must match the syntax of the chosen language, for example the operators of range and others should match the encapsulation language
The following operators will be build into the OpenODD Format:
Operator |
Description |
Example |
Comment |
|
plus, Addition |
x+y |
will return the added value |
|
minus, Subtraction |
x-y |
will retrun the subtracted value |
|
multiplicator, Multiplication |
x*y |
will return the multiplicated value |
|
divider, Division |
x/y |
will return the divided value |
|
modulo, Modulus |
3%2 = 1 |
will return the modulo value |
|
Floor division |
x//y |
|
|
negation, equivalent to "NOT" |
!(y<5) |
|
|
asign |
x=y |
will assign a value to a variable |
|
equal |
x==y |
will return a bool |
|
not equal |
x!=y |
will return a bool |
|
equivalent "AND" |
x AND y |
will return true if x and y is true |
|
equivalent "OR" |
x OR y |
will return true if x or y is true |
|
less |
x<y |
will return a bool |
|
less equal |
x⇐y |
will return a bool |
|
greater |
x>y |
will return a bool |
|
greater equal |
x>=y |
will return a bool |
|
element in sequence |
x in [a,b,c] |
will return a false |
|
element not in sequence |
x not in [a,b,c] |
will return a true |
4.4.8. Hierarchy
The language format needs to be able to express the class hierarchy provided by the attribute group (WP01), it needs to support inheritance, be consistent with the class categories (keywords), data type and units. It shall support abstract ODD definitions by choosing different hierarchical levels.
Example use cases: Inheritance
Challenge: Define a restrictive ODD that specifies motorway as the allowed road type, and junctions are not suitable. In addition, everything else that is not mentioned is not allowed. In this case, when the hierarchical class 'Junctions' is used, the restriction will automatically inherited by all its sub-classes, this is similar to the next abstraction example.
Example representations:
-
Syntax 1
import PAS_1883 # Assuming this includes PAS1883 fully elaborated ODD extend junctions_type: # No junctions of any sub-type allowed keep(size == 0) restrictive_odd: ODD: keep(road_topology.drivable_area.road == motorway) # only motorways allowed keep(all_default_values()) # restrictive, only explicitly included values allowed -
Syntax 2:
MODE Restrictive INCLUDE PAS_1883.owl SUITABLE motorway UNSUITABLE junction # this unsuitability is automatically inherited by all the types of junctions under the junction class
Example use cases: Abstraction
Abstraction allows the user to define the ODD at any level of abstraction corresponding to the Ontology
Define a ODD that allows all dynamic elements defined in the ontology, except when there is any type of rain. In this example, ODD can be specified at the 'Dynamic elements' level, the semantic echos with the inheritance property which means all the sub-classes of 'Dynamic elements' are also applied.
Example representations:
-
Syntax 1
import PAS_1883 # Assuming this includes PAS1883 fully elaborated ODD no_rain_odd: ODD keep(dynamic_elements.weather.rain == none) # Disallow rain -
Syntax 2:
SUITABLE Dynamic Elements EXCEPT WHEN rain
4.4.9. Permissive and restrictive definition
Permissive/Restrictive modes can be considered in two levels — at the individual statement level, and at the global level.
At the individual statement level, the language should take a mixed permissive and restrictive approach within its statements in order to be flexible when defining what is inside/outside the ODD (using explicit statements for inclusion or exclusion along with conditionals). The user of the language is responsible when specifying multiple permissive/restrictive expressions to guard from changing scope.
At the global level, restrictive mode is recommended to be considered such that ODD attributes that are not defined with statements can be evaluated by default to NOT allowed. This is particularly handy in the usual case where your custom ODD definition is based on an existing ontology (see importing an existing ODD ontology at the beginning of your new ODD definition) or when expressing a narrow ODD. Below is a reference from MUSICC (Multi User Scenario Catalogue for Connected and Autonomous Vehicles) project which defines the global permissive/restrictive. Design considerations for ODD ontology by CATAPULT, March 2020. Users can choose to define an ODD using permissive at the global level where ODD attributes that are not defined with statements can be evaluated by default to allowed. This can be useful in expressing wide ODDs.
"Conditions may exist in the real world which are not modeled in the ODD ontology, and therefore cannot be represented in an ODD specification. With a restrictive ODD definition, it is clear that these are outside of the ODD, which is consistent with the SAE J3016 definition(since the ADS is unlikely to have been “specifically designed to function” with an unforeseen feature). If the ODD definition is permissive, it is unclear whether the element is allowed for the vehicle or not. […]For a hierarchical structure to be useful, it should be possible to use combined expressions (e.g.“Rural roads except motorways”); otherwise, all but the simplest of ODDs require every leaf item to be specified."
| ODD statements' permissive/restrictive mode should not be confused with natural language permissive/restrictive classifications (i.e. in the natural legal language "The court allows act x" is classified as permissive language while in the ODD language the same expression denotes a restrictive mode). |
Example use cases: ODD definition for a T-Junction
For the example t-junction represented in the image and ontology below. Lets consider what permissive and restrictive means at a global level. For this we will have no 'local' statements so that we can visualize the effects of the 'global' permissive/restrictive.
Using a restrictive base state. A 'blank' ODD definition for the attached t-junction ontology would mean that all leaf attributes can be considered as outside of the ODD: restrictive - any attributes that are not mentioned in the ODD description but are present in the ontology (T-junction ontology) are assumed outside of the ODD’s scope.
Using a permissive base state. A 'blank' ODD definition for the attached t-junction ontology would mean that all leaf attributes can be considered as inside the ODD: permissive - any attributes that are not mentioned in the ODD description but are present in the ontology (T-junction ontology) are assumed inside of the ODD’s scope.
Note that in both examples ideally attributes that require numeric input would be separately defined, as these could not be simply included/excluded. i.e lane dimensions should be defined regardless of base state for clarity of description.