CASCaS

The objective of the Cognitive Architecture for Safety Critical Task Simulation (CASCaS) is the simulation of human behaviour in a man-machine environment within a safety critical (work) domain like for example aircraft pilots, car / truck drivers or navigation officers on a ship bridge. Within these simulations specific test scenarios are defined for a system under investigation to simulate the human-machine interaction and systematically test the system design by varying scenario parameters, but also by varying the behaviour of the CASCaS model (e.g. different driving styles).

The figure below shows an example of a CASCaS driver model instance driving on a German Autobahn in moderate traffic. The model (Weber, 2013) simulates the typical driving manoeuvres free-flow, car-following and lane changes left / right (Driver Model Video). A 3D vision model is implemented for fovea and peripheral vision. To observe the surrounding traffic the gaze through wind shield and the use of both side mirrors is implemented into the task model. The model observes the traffic situation, estimates potential gaps and decides for an appropriate driving maneuver.

screenshot-drivermodel

The driver model simulation but also aircraft pilot simulations typically involve a number of different components:

  1. a full-fledged real-time simulation software for the respective domain including traffic simulation, vehicle dynamics, scenario modelling (e.g. road geometry, environment) etc. and the capability to integrate a human behaviour model (create appropriate input which is sent to the CASCaS model, receives control actions from the model) .
  2. a specific application scenario, like a flight scenario (e.g. a final approach procedure to land on an airport) or driving maneuver (e.g. lane change situations, car-following)
  3. a system under investigation which is used by the CASCaS model: driver assistance system (e.g. adaptive cruise control, lane change assistance, blind spot warning), flight system (e.g. autopilot).
  4. one or more instances of CASCaS to simulate the human operator behaviour within the simulated scenario

We try to make use of already existing models and extent their capabilities in successive research projects (basic and applied research, nationally and EU-wide).

Brief Introduction to CASCaS

architecture

One of the basic mechanisms behind CASCaS is the simulation of goal-oriented, rule-based behaviour written in a procedure file which is loaded by the architecture before the simulation starts. In such a procedure goals specify the intentions of the model (what to do next), while for each of these goals a set of rules specifies different action plans (how to achieve the goal). The tasks (consisting of goals and rules) are stored in the models long term procedural memory, while at runtime the goal module and the associative layer are responsible for the execution of these task knowledge. Besides top-down processing of procedural, domain specific task knowledge, CASCaS can also react on external events which are detected by the perceptual components (e.g. by detecting a flashing brake light ahead via peripheral vision, or an acoustic signal). Such events can initiate also the execution of further new goals and rules how to deal with interruptions. We call this type of processing bottom-up. On a lower cognitive level CASCaS executes percept-motor patterns, for example moving a hand towards an object, pressing a button or also how to use a steering wheel or an accelerator pedal. These highly learned behaviors are triggered by the associative layer but the execution on the autonomous layer is done with less conscious control.

The interaction between both layers and the difference of bottom-up / top-down processing can be described best with a short example: imagine a driver model driving on a rural road. Via peripheral vision the driver model detects a traffic sign (assume a speed limit sign) and shifts its gaze towards this object. It now looks at the sign, reads its content with the fovea vision which and stores a symbolic knowledge fact (the speed limit) in the working memory component. The model also has procedural knowledge that whenever a new speed sign is detected it has to check and potentially adjust its driving speed. Thus, a top-down process is initiated by the associative layer which triggers the visual perception to look at the speedometer. The model now reads the cockpit instrument, compares the speed limit fact and actual speed and recognises that it is too fast. The associative layer now triggers a percept-motor pattern on the autonomous layer to adjust the speed. Such a pattern executes muscle movement to change the foot position on the accelerator pedal or to press the brake pedal if necessary. Additionally, the goal module and the associative layer guide the visual perception to constantly (or at least periodically) perceive the actual speed which is necessary to finish the goal to adjust the speed.

This example shows that even “simple” actions are composed out of a larger set of small behaviors which involve a lot of different components of the architecture. Dependent on the detail of the procedure model and the granularity of the implementation of the percept motor patterns the overall behavior model can become rather complex. The before mentioned driver model consists of roughly 120 rules and 15 goals to be able to deal with the Autobahn task but at many things it still is a very rough abstraction.

Development History

The original implementation of CASCaS in Prolog was done by Andreas Lüdtke (Lüdtke, 2005) during his dissertation (2002-2005) where he simulated the phenomenon called “learned carelessness”: a simplification of rule-based task structures which can lead to erroneous behavior in the context of human-machine interaction. Because of several extensions later on the internal structure of the model became to complex and was no longer maintainable. The decision was made to re-implement the whole model (at the beginning of 2007) on a c-code basis, which is still used today. Major contributions to the implementation of today’s architecture were made by Lars Weber, Jan-Patrick Osterloh and Bertram Wortelen.

On this basis CASCaS offers the possibility for extensions via user defined modules that are integrated as dynamic link libraries (.dll file). CASCaS comes with specific simulation interfaces to support TCP-IP / UDP connections using real-time and simulation time, as well as HLA-2000 simulation standard interface to connect to external simulators.

Until today the architecture was successfully applied in several projects (EU and nationally in Germany) to model pilot and crew behaviour performance. Since 2008 the driving domain emerged as second main application and lately (since 2012) we started some projects in the maritime domain also. Publications for these domains can be found on the References page.

A more detailed introduction about the architecture can be found in the Part1-Introduction-to-CASCaS.pdf (Stand 21.12.2016)