Stefano Centomo
email: stefano.centomo@studenti.univr.it

Julien Deantoni
email: julien.deantoni@polytech.unice.fr

Robert De Simone
email: robert.desimone@inria.fr

Using SystemC Cyber Models in an FMI Co-Simulation Environment: Results and Proposed FMI Enhancements

The development of Cyber Physical Systems (CPS) requires to model both the cyber (i.e., digital) parts, the physical parts and the interaction between them. The state of the practice in such domain usually involves different stakeholders, which use dedicated modeling languages tailored syntactically and semantically to their domain. Functional Mock-up Interface (FMI) is a recent standard, which provides technical facilities to enable the co-simulation among the different dedicated modeling languages. In this context, this paper investigates how discreteevent models of the cyber part are supported by FMI standard for co-simulation. Two main results are presented: 1) how SystemC models can be integrated into the FMI environment and 2) FMI limitations for the efficient use of discrete-event models in cosimulation. Both results are illustrated by using a simple but illustrative use case mixing models in SystemC (for the cyber part) and Modelica (for the physical part).

I. INTRODUCTION

Cyber-Physical systems become more and more complex. A major characteristic for the simulation of such systems is the mix of discrete-event models for the cyber part and dense/continuous time models for the physical part. With the growing complexity of CPS, different stakeholders are usually involved in their development. These stakeholder can use a language specifically tailored for its domain. However, this approach leads to a mix of heterogeneous models whose simulation requires to specify the interaction/coordination between these models [START_REF] Combemale | Globalizing Modeling Languages[END_REF].

Recently, FMI [START_REF] Modelisar | FMI for Model Exchange and Co-Simulation[END_REF] appeared as a co-simulation standard to make different executable models (denoted as FMU for Functional Mock-up Units) working in a coordinated way. FMI was designed to support the coordination of equation based models, either discrete or continuous. They defined an application programming interface and two operational modes, i.e., model exchange and co-simulation [START_REF] Modelisar | FMI for Model Exchange and Co-Simulation[END_REF]. This paper focuses on the co-simulation mode where each model is simulated independently by its own solver and a master algorithm is used to convey data and ensure time consistency between the different models/simulators at specific discrete time points. In this mode, the simulation is time driven, meaning that the internal state of a model under simulation can only be queried at specific time points (named communication points). It fits correctly the semantics of many persistent signal-based models (e.g., Ordinary Differential Equations or some discrete equation model for controllers). However it currently does not support well some kinds of cyber models for digital hardware or communication systems where a discrete-event simulator is used (e.g., SystemC (http://www.systemc.org/home) models or network models written in NS-3 (http://ns3project.com/ ns3-simulator/) or SCNSL [START_REF] Fummi | A systemc-based framework for modeling and simulation of networked embedded systems[END_REF]). There exist different studies on the use of SystemC or other discrete-event languages in FMI co-simulation [START_REF] Broman | Determinate composition of fmus for co-simulation[END_REF], [START_REF] Tripakis | Bridging the semantic gap between heterogeneous modeling formalisms and fmi[END_REF], [START_REF] Cremona | Fidean fmi integrated development environment[END_REF], [START_REF] Bucs | Virtual hardwarein-the-loop co-simulation for multi-domain automotive systems via the functional mock-up interface[END_REF], [START_REF] Krammer | Standard compliant co-simulation models for verification of automotive embedded systems[END_REF], [START_REF] Pedersen | Co-simulation of distributed engine control system and network model using fmi & scnsl[END_REF], [START_REF] Müller | Linking fmi-based components with discrete event systems[END_REF]. Many of these studies focused on how to make cyber models actually working in interaction with physical models. However the details of why and how the cyber models communicate through FMI are usually not given. When these details are given, the approach somehow explains how to force the required semantic adaptation instead of pointing some shortcomings of FMI.

This paper addresses how the FMI standard can support discrete-event cyber models (written in SystemC) for cosimulation. Our goal was to understand to what extend FMI is suitable to be used with such models. Towards this goal, we realized an automatic export of SystemC design specification in FMI. Then we co-simulated a specific SystemC design together with a simple physical model written in Modelica (https://www.modelica.org/). Based on these experiments, we found some shortcomings of the FMI standard, which forbid writing an efficient master algorithm. These shortcomings are mainly concerned with discontinuities both in time and value, which exist in most cyber models. Also from these experiments, we believe it could be interesting to allow not only a pure time-driven master algorithm but a mixed timeand event-driven master algorithm.

The paper starts with some useful reminders about the FMI and SystemC standards in Section II. Then, the export from SystemC to FMI is detailed, together with the adopted restrictions and choices (Section III). Based on this export, we explain some experiments based on the co-simulation between SystemC and Modelica models. We show timing results in different conditions, helping understand why and when performance issues can arise (Section IV). Then, FMI limitations are explained, together with some proposition to overcome them (Section V). Finally, after a positioning of our approach compared to existing work in Section VI, we conclude and sketch some future works in Section VII.

II. BACKGROUND ON FMI AND SYSTEMC

In this paper we are using the FMI 2.0 standard as cosimulation environment and SystemC to specify the cyber models. Both FMI and SystemC are introduced in this section.

FMI is a tool-independent standard framework to support co-simulation of dynamic models. The FMI standard is managed and developed as a Modelica Association Project. FMI provides a standardized interface allowing different executable models (named FMU: Functional Mock-up Unit) to be controlled by an external software. FMI supports two closely related time-driven control modes, i.e., model exchange and co-simulation. In the context of this paper, the co-simulation mode is targeted. In co-simulation mode, the data exchange between subsystems is restricted to discrete-time communication points. In the time between two communication points (i.e., during a communication step), the subsystems are solved independently by each FMU simulator. A "coordinator" controls data exchange between subsystems and the synchronization of all simulation solvers by choosing the communication step size (see Figure 1). The coordinator is not part of the FMI standard. The most common coordinator algorithm runs each FMU for a fixed communication step size and collects the outputs from all subsystems. Then, it evaluates the subsystem outputs and distributes them to the FMU of interest. Finally, it continues the (co-)simulation for the required simulation time. Technically, a FMU is a zip archive that contains two main files: 1) a dynamically-loadable library implementing the model simulation and providing the C-language FMI API, and 2) an XML description of the model interface. The model description file follows a specific XML schema defined by the standard, which contains all the information about the input and output variables of the model. These variables, named "exposed variables", define the communication channels between the FMU and the coordinator. For each variable, it defines its direction (e.g., input, output or parameter), its type among Integer, Boolean, String and Real (respectively named Fmi2Integer, Fmi2Boolean, Fmi2Real and Fmi2String) and an identifier, which is unique for a specific data type: the value reference. In the co-simulation mode, the coordinator can set or get the current value of an exposed variable (according to its direction) by using the standardized FMI API at specific communication points. This API is also used to simulate the model for a specific interval of time slice by specifying a start/end time (doStep method). In the co-simulation mode, the FMU solver decides how many computational steps should be done by the FMU in those time interval to reach the desired precision. Another interesting FMI feature is the possibility for an FMU to reject a proposed step size if an internal important action occurred during the step computation. In this case the FMU returns its actual time to the coordinator, which can get or set the FMU exposed variables. Based on the FMI standard, we aim at studying how cyber models and, specifically, SystemC digital hardware models can be used for co-simulation.

SystemC is a hardware description language, meant to represent circuits and SoCs at various levels of abstraction (in particular at RTL and TLM levels). Since it is a library designed as an extension of C++, it benefits the data types and compiler environments from this host language. It adds provisions for components (modules), ports, parallel threads, signal wires, clocks, timing features, low and high level communication mechanisms. These extensions are semantically dealt with by a non-preemptive scheduler for simulation. Simulation goes through different phases. First, the elaboration phase instantiates the parallel components and their static network (i.e., the sc modules and their interconnects). Then the actual evaluation/update cycle takes place, executing the individual components according to the scheduler policy. Simulation itself can be untimed (causal), cycle-accurate, or loosely timed. In this paper we consider timed designs. The SystemC kernel relies on a discrete-event simulator where time-stamped events are put in a queue and processed in time order. The time between two successive events in the queue can be arbitrarily long. To simulate a SystemC design we need to bind its input and output ports to another component named test-bench. The main role of the test-bench component is the stimulation of the design and the verification of resulting outputs. Consequently its interface is the mirror of the design interface; the input ports of the design are output ports for the test-bench and vice versa.

III. EXPORTING SYSTEMC RTL DESIGN AS FMUS

SystemC can be used to specify cyber models at different abstraction levels, ranging from transactional un-timed to cycle-accurate levels. As a first step, because FMI is time driven, we deal with the export of legacy SystemC RTL models written with the SystemC reference library implementation (http://www.systemc.org/downloads/standards/systemc). In order to export an FMU from a SystemC RTL design, several steps are required (see Figure 2). All these steps are fully automated, making the creation of an FMU transparent to the user. The first step consists in extracting the list of all the exposed variables from the SystemC design specification. SystemC is a component based language where a component (module) exhibits some input and output ports. Our goal in this step is consequently to retrieve all the ports at the top level of the design, their direction, and their type. We go further by extracting an IP-Xact [START_REF]IEEE 1685: IP-XACT, STANDARD STRUCTURE FOR PACKAGING, INTEGRATING, AND REUSING IP WITHIN TOOL FLOWS[END_REF] representation of the SystemC design. In the general case, dynamic allocation of port arrays or arbitrary many components can be instantiated and linked together during the elaboration phase of SystemC. Consequently this step relies on both static and dynamic analysis (see Section III-A). Once all the required information is extracted, we automatically generate the XML model description file (Step 2 in Figure 2, detailed in Section III-B). Then, the third step is an important step that can be decomposed into different activities. First, because a SystemC design with unconnected ports can not be simulated, we automatically create a new SystemC module whose goal is to access the exposed variable of the design (named FMI Proxy on Figure 2). Second, this new module must implement the FMI API. It actually plays the same role than a classical test-bench in the sense that it stimulates the design (i.e., it sets some data/events) and retrieves the modified outputs (i.e., it gets some data/events) from the ports of the design. However, instead of following a specific test plan, it operates according to commands from the FMI coordinator. Finally, it is interesting to keep the time-stamped history of the exposed variable values between two communication steps (see section V). Therefore we also equipped the FMI Proxy with a trace management unit, which extends the open source SystemC library. All the details about these steps are given in Section III-C. After this step, all the generated code can be compiled as an executable binary. We cannot directly export the resulting code as a library since a SystemC design already contains a main function. Step 4 is then in charge of creating the appropriate wrapper so that the design can be exported as an FMI-compliant dynamic library (see Section III-D). The last step consists in zipping the model description file and the dynamic library. This step is straightforward and not further detailed.

A. Exposed Variable Extraction

The first step towards the FMU generation is the extraction of the interface of the design, i.e., its ports, their direction and their types. In order to retrieve correctly this information, we rely on both static and dynamic analysis by using SCiPX [START_REF] Tallec | Scipx: A systemc to ip-xact extraction tool[END_REF]. SCiPX is a tool, which extracts a high level interface description in the IP-XACT standard [START_REF]IEEE 1685: IP-XACT, STANDARD STRUCTURE FOR PACKAGING, INTEGRATING, AND REUSING IP WITHIN TOOL FLOWS[END_REF] from SystemC code.

SCiPX starts by generating the documentation of the design by using Doxygen (http://www.stack.nl/ ∼ dimitri/doxygen/ index.html) and making a static analysis of the documentation, retrieving all the types used in the design. After that, by using LLVM, it analyses the traces to understand which modules and ports are actually instantiated.

Results from both static and dynamic analysis are then reassembled into an IP-XACT compliant syntax. The IP-XACT specification provides an abstract model of the Sys-temC design from which it is possible to specify the needed model transformations.

B. XML Model Description Generation

Starting from the IPXACT description of the SystemC design, generated by SCiPX, our approach uses a model-totext transformation, implemented in Acceleo (https://eclipse. org/acceleo/), to generate all the files needed to export the model as an FMU. The export starts by generating the modelDescription.xml file. This file, whose syntax is defined by the FMI standard, contains all the information about the exposed variables of the FMU. For each exposed variable the description defines its type, its direction and its value reference (see section II).

In one hand, FMI defines only four data types: Fmi2Integer, Fmi2Boolean, Fmi2Real and Fmi2String. In the other hand, SystemC is a library that extends C++ with extra types like, for instance, sc logic, which is the representation of an actual binary signal that can take 4 different values ('0', '1', 'X' and 'Z') 1 . To export a SystemC design we had to map all the SystemC types into the four FMI types. Of course, at this step we could loose information since types in SystemC are more expressive than FMI ones. We used the following mapping:

• sc uint,sc int,sc bit,sc bv and all the "int-based" types from C++ like uintX t are mapped to Fmi2Integer. • sc bigint and sc biguint are used for values greater then 64 bits while Fmi2Integer is encoded in 32 bits only.

Since the loss of information can be too consequent to make sense, we decided to reject design exposing sc bigint or sc biguint. • sc logic and sc lv are mapped to Fmi2String. While this is quite easy to achieve, it imposes that the FMU(s) receiving such variable are aware of the encoding. • bool C++ type are mapped to fmi2Boolean.

• float and double C++ types are mapped to Fmi2Real. All the other structured C++ types (e.g., classes or structures) are not supported as exposed variable since there is no clear way to map them to the FMI types. It is also required to map the exposed variable direction. There are several kinds of directions, but the two main ones are input and output. In our case the exposed variables of a SystemC design are its ports whose direction is clearly defined in SystemC.

C. FMI Proxy Generation

To be able to simulate a SystemC design, all its ports must be bound, otherwise, the kernel will stop during the initialization phase and won't start the simulation. To allow the simulation, we automatically generate a new SystemC component named FMI proxy, whose ports have the same types than the ports of original design, but with the opposite direction. In our approach we want to save the history of the exposed variables during a communication step. To do so, our approach generates another SystemC component named FMI Manager, which is responsible of saving the values of all the exposed variables during one step of the simulation. In SystemC there is a trace mechanism encoded in the VCD classes, used to trace value of the design ports. This mechanism ends up with a VCD file that contains the simulation history of the traced ports. To take advantage of this mechanism, we extended all of the VCD classes from the SystemC library so that they contain an array of Snapshots, which represents the entire history of all the values of the simulation of that port. For each snapshot, our FMI Manager saves all the values of the ports as well as the time of the changes into a special classes structure. We coded the information of the time into two classes called FMI Time Step and FMI Micro Step (i.e., the trace encodes super dense time). The FMI Micro Step represents the delta cycle and it contains an index, that is the number of the delta cycle, and an array of FMI Snapshot references. An array of FMI Snapshot is needed because it is possible to have many new values in a single delta cycle. The FMI Time step represents the time step; it has a time attribute and an array of FMI Micro Step references, because for a single time step it is possible to have several delta cycles. When the simulation moves forward, the SystemC kernel calls the cycle method from the VCD classes but overridden in our trace manager to create the trace structure. This resulting class structure (see Figure 3) allows to retrieve all the value change information without data redundancy; i.e., starting from a time step it is possible to retrieve all the micro-steps and all the snapshots of that time step, and, starting from a snapshot, it is possible to retrieve the relative micro-step and time step where its value changes. This kind of structure is named "Multi-dimensional trace" [START_REF] Bousse | Towards scalable multidimensional execution traces for xdsmls[END_REF].

The transformation also generates a main.cpp file, where these two modules are instantiated and bound together. Actually, because the original main file can be quite complex (due for instance to the initialization phase), the new main.cpp is a clone of the original one with additional lines to instantiate and bind the newly generated component. In the main.cpp the transformation also creates an instance of the FMI Manager, and the instructions to trace all the ports of the design.

Another important added part is the clock generator, needed to export synchronous RTL designs. During the transformation process, it is asked the user whether the model needs a clock generator or not and, if needed, what is the master clock Once all these files generated, we can compile the resulting code and obtain an executable. However, it is not possible to export a SystemC module, with the SystemC kernel as a library without modifying the source code of the SystemC kernel. The problem comes from the entry point of the program (the main() function), which is hidden inside the SystemC library itself. To overcome this problem, we create two processes with inter process communication in between. This is detailed in the next Section.

The type mapping between SystemC and FMI is the same as the one defined in Section III-B. Additionally, FMI provides the signature of a set of C functions and their role in the communication between the coordinator and an FMU. We now have to implement these functions in the Fmi Proxy component to allow communication with the coordinator.

There are six main functions defined by the FMI standard for co-simulation: Fmi2Set, Fmi2Get, Fmi2Instantiate, Fmi2SetupExperiment, Fmi2DoStep and Fmi2FreeInstances. a) Fmi2Set and Fmi2Get: permit to set and get the values of the exposed variables from and to the coordinator. There are actually four kinds of set and get methods, one for each data types of the standard. For instance the set method for the Fmi2Integer exposed variables is Fmi2SetInteger, for Fmi2Real exposed variables is Fmi2SetReal and so on. For a specific data type, each exposed variable of this type is identified uniquely by an ID called value reference. In the FMI Proxy we generated four vectors, one for each FMI type, which contains the pointer to the exposed variable. The position in the vector of each exposed variable corresponds to its value reference.

b) Fmi2Instantiate: is responsible for the instantiation of the FMU, more in details it must call the generated main.cpp file, in charge of instantiating the design, the FMI Proxy, the FMI TraceManager and corresponding bindings. The exact implementation of this function is detailled in the next Section. c) SetupExperiment: This method initializes the FMU with the initial values of the exposed variables given in the XML file. It also executes the initialization phase of the model and of the FMI Proxy. To do that, the sc start() method is used. While usually it takes an argument defining the simulation time, when given with a value of zero, it runs until the next micro step. In consequence, the first call of sc start(0) runs the elaboration phase but stops before the actual simulation.

d) Fmi2Dostep: is the core function of the co-simulation interface because it simulates the model contained in the FMU for a specific time interval. Once again, the sc start() function is used with, as parameters, the difference between the end and the start times asked by the coordinator.

e) Fmi2FreeInstances: frees all the structure and the resources used by FMU. When the coordinator calls this function the FMI Proxy calls the sc stop() SystemC function, which stops the simulation, deallocates the structure from the memory and frees the resources.

Since the IP-XACT description does not hold clock information and consequently the transformation is parameterized by the user to know if the design needs a clock generator or not and, if needed, what is the master clock port. The clock generator is a process inside the Fmi Proxy, generated automatically and linked to the port indicated by the user. The transformation is also parameterized by the clock period of the clock generator.

D. Creation of the FMI-compliant dynamic library

In the FMU, the simulation model must be provided as a C library (i.e., .so or .dll), with the implementation of all the functions defined by the FMI standard. As explained previously, it is not possible to export a SystemC RTL design as a library due to the program entry point already defined in the SystemC kernel library. Because we did not want to modify the SystemC library, we compile the SystemC design as an executable and we launch it in a specific process. The actual interface with the coordinator is then launched in another process and inter process communication is used between them. We consequently defined a communication protocol between the two processes to exchange data and commands. It is clear that our solution suffers the inter process communication cost because we did not want to modify the SystemC library. However, future work will investigate a solution in which the SystemC library is slightly modified to avoid such cost. The commands defined in the protocol are: Set, Get, Simulate and Finish. In the FMI Proxy there is a main routine that is responsible of mapping these commands and their parameters from and to the FMI interface functions. For instance, considering that the coordinator calls the Fmi2Set function, the pipe conveys the Set command followed by the FMI type, the value reference of that type and finally the new value to set. All the other commands and their results are communicated through the pipe in the same way.

IV. EXPERIMENTS AND RESULTS

By using the proposed automatic generator, it is possible to export a model that describes a cyber system written in SystemC RTL into an FMU with the co-simulation interface. It is then possible to co-simulate it with other FMUs.

In this section we depict an experiment that co-simulated two FMUs connected by a coordinator written in pyFMI (http://www.jmodelica.org/page/4924), a python bridge to the official FMI library. The FMU exported from a SystemC model is co-simulated with a Modelica FMU.

The Modelica FMU is a resistor-capacitor electric circuit with two generators and a switch, named openclose (see Figure 4). The exported electrical model, named Heating Resistor FMU, describes the thermal behavior of a CPU in which the switch state represents the activity/inactivity of the CPU. This FMU has several exposed variables that can be set and get from the coordinator. In our experiments we fixed the values of the generators, the resistor and the capacitor. We used only two exposed variables: the openclose Boolean input variable representing the state of the switch, and the Cpu temp Real output variable that represents the temperature of the CPU.

In our experiment, the SystemC FMU, named Timed FSM FMU, describes an overly simplified temperature manager specified by a timed state machine with two states S1 and S2 and a single Boolean output exposed variable (openclose). After 40 seconds in the state S1, the transition between S1 and S2 is fired. During this transition the openclose variable is changed from false to true. After 40 seconds in state S2, the transition from S2 to S1 is fired, changing openclose to false.

After coding the state machine in SystemC, we generated the Timed FSM FMU by using the proposed tool with a clock generator process and a clock period of 1 second. In this case, because there is only a (one way) causality from the SystemC to the Modelica model, the coordinator simulates the Timed FSM FMU until the openclose changes. To do so, the coordinator calls the Simulate method with a specific start and end times (explained later) until the openclose exposed variable changes. When it changes it saves the current simulated time. Then, the coordinator simulates the Heating Resistor FMU for the previously saved amount of time (with the value the openclose exposed variable had on this interval). In other words, since the causality is one way, the coordinator simulates the state machine until the openclose variable changes and then it simulates the physical model for the amount of time between two changes of the openclose variable.

To understand how to make efficient co-simulation, we varied the transition time between S1 and S2. As a result, both the simulation time and the number of integration steps made by the Modelica solver decrease when the size of the communication step increases (see Figure 5). This was expected since the integration steps are (usually) optimized when the required simulation step size increases (see Figure 6 where the number of integration steps computed by the solver decreases when the communication step size increases. This is mainly due to the optimization of the integration step size according to the derivatives of the model variables when the communication step size is big enough).

V. FMI LIMITATIONS

From the various experiments driven by our automatic export of a SystemC design as an FMU, we identified some lacks of FMI, which forbids an efficient co-simulation of cyber and physical models. This section explains these lacks and sketches propositions toward a conservative enhancement of the FMI API.

A. History of values between communications points

During a co-simulation, the coordinator can retrieve the current value of the exposed data at discrete communication points. Additionally to its current value, the derivative of continuous-time data can be retrieved (e.g., to enable interpolation). However, when a cyber model is simulated, there are discrete-time data, which can change arbitrarily often; i.e., very often at a specific point of the simulation and almost never at some other points and possibly with an infinite derivative (consider for instance the current state of a state machine or the Boolean state of a button). Retrieving the current value of these data at the considered communication points is not efficient an can lead to a loss of information or precision.

For instance, let us consider a simple system with three FMUs. The first FMU is a cyber model which deals with a push button. Its exposed variable is the state of this button. A second FMU is again a cyber FMU in charge of interpreting the action on the button: One "short" push on the button create a toggle command for a light in the environment, managed by a third, physical, FMU. One "long" push on the button when the light is already on must order an increase of the light luminosity according to the time the button is kept pushed. Finally the third FMU manages the light and its effect on the physical environment. In this specific case the second FMU need to know the state of the button given by the first FMU but it also needs to know the timing associated to this state. If the communication step size is too big, then some discrete time information can be lost (see left part of Figure 7). Also, when it is required to compute the time a specific value is maintained, the size of the communication step must be chosen according to the expected precision in time (see right part of Figure 7). In both cases the communication size can be reduced enough to reduce the problems. However it comes with a significant increase of the simulation time as shown in the experiments section when increasing the number of communication points. Additionally, reducing the communication step size is not a solution to correctly handle sequences of events or value changes occurring in zero time; i.e, value changing during micros steps of the simulation (see for instance the rational of super dense time [START_REF] Lee | A framework for comparing models of computation[END_REF]). The reader should note that we are not claiming that such behavior cannot be encoded in FMI (for instance by using rejected steps and absent values [START_REF] Tripakis | Bridging the semantic gap between heterogeneous modeling formalisms and fmi[END_REF]). What we want to stress is that, in cosimulation mode of cyber models it can be problematic to retrieve only the current value of exposed variable at discrete communication points. It can lead to an unnecessary increase of the communications between FMUs and the coordinator, leading to bad performances.

What we propose to solve this problem is the possibility to retrieve all the time-stamped values of a data, which occurred during the communication step. This would avoid reducing the communication step size while enabling the coordinator to query the history of the data in order to avoid information loss and obtain a better precision about the timing. In order to be compliant with what is existing in the FMI standard, it could be possible to use a super dense time trace of the data evolution when retrieving its values at communication points.

In the same idea, it could be beneficial to enable setting not only the current value of an input exposed variable at a specific Fig. 7. Problem when only the current value is retrieved at communication points Fig. 8. Problem when using a periodic system with a period >> WCET communication point but rather to provide a temporal sequence of value changes during a communication step. Once again it would reduce the required number of communication points. While this is quite obvious how to do it for cyber models, how to manage such input trace efficiently for physical models is an open problem we did not study yet.

B. Event driven communication with FMUs

The co-simulation mode of FMI is time-driven. The communication between an FMU and the coordinator is made at regular points in time named communication points. This is convenient for the persistent signal-based semantics of the systems originally targeted by FMI. However, when used with cyber models following the Discrete Event semantic model, it becomes cumbersome. For instance, let us consider a model of a real time system. It works periodically for a maximum amount of time denoted WCET (Worst Case Execution Time). When the period is largely bigger then the WCET (see Figure 8) the coordinator queries the FMU at regular points in time even if the system is actually not doing anything. This is mandatory since the FMU is seen as a black box and the communication step size has to be adequate to the time between successive actions when the system is working.

Nowadays, to avoid this undesired behavior, the coordinator can use variable communication step size. However, because an FMU is a black box from the coordinator point of view, the coordinator has to adapt the step size by using a try and error mechanism. To avoid this, it seems interesting to add the possibility to simulate an FMU until the next change on its exposed variable. In this hypothesis, the coordinator run the FMU without ending time (i.e., with an a priori infinite communication step size), the ending time being given by the FMU when it pauses its simulation. Note that, if the coordinator is interested by any change in any of the exposed variables, this behavior can be encoded with the actual FMI API by asking an FMU to simulate for a ridiculously big amount of time. In this case the FMU can reject the proposed step size at the time the first changed occurred. In this case it can still advance for the processed amount of time. However, for more flexibility the proposed API could be used to specify a list of sensitive exposed variable, asking the FMU to stop only when a change occurs on these sensitive variables.

Note that this proposition could also make sense in the context of physical model for which we want to simulate until the next zero crossing of a sensitive exposed variable.

C. Native Event Type support

FMI supports only 4 data types. When considering some cyber system specification languages, the notion of event is of prime importance (see for instance synchronous programming languages like Signal or Esterel [START_REF] Benveniste | The synchronous languages 12 years later[END_REF], or languages used to react to user actions like Javascript (http://www.w3schools. com/js/js htmldom events.asp) or Qt (https://www.qt.io/)). As stated in [START_REF] Tripakis | Bridging the semantic gap between heterogeneous modeling formalisms and fmi[END_REF], FMI badly supports the notion of Events. It seems interesting to natively support the Event type in order to ease co-simulation of cyber models. The Event type value could then be a couple timestamp and eventually a data type value.

VI. RELATED WORK

We know three other approaches that export a Sys-temC design as an FMU: [START_REF] Bucs | Virtual hardwarein-the-loop co-simulation for multi-domain automotive systems via the functional mock-up interface[END_REF], [START_REF] Vachoux | Systemc-ams requirements, design objectives and rationale[END_REF], [START_REF] Pedersen | Co-simulation of distributed engine control system and network model using fmi & scnsl[END_REF]. However there exist fundamental differences between these approaches and the one proposed in this paper. In [START_REF] Bucs | Virtual hardwarein-the-loop co-simulation for multi-domain automotive systems via the functional mock-up interface[END_REF], the authors proposed an approach to export a SystemC virtual platform as an FMU. Their approach strongly depends on the Platform Architect tool (http://www.synopsys.com/Prototyping/ ArchitectureDesign/Pages/platform-architect.aspx) and consequently the paper only presents an high level architecture of the proposed solution. Many components of their architecture were already covered by Platform Architect (e.g., the extraction of the exposed variables or the required interface to get and set them). The approach is consequently available only in platform architect. More importantly they do not give any detail on the flavor the SystemC design must conform (RTL only ?, TLM ?, timed ?). This makes difficult to understand if they solved the various issues that can arise, for instance when using untimed designs. In the opposite, in this paper we made clear that only RTL synchronous SystemC designs are supported for now. We also detailed all the steps needed to create an FMU based on the open source SystemC library. Finally, we proposed extensions to the FMI standard for a more efficient support of cyber models in co-simulation. In [START_REF] Pedersen | Co-simulation of distributed engine control system and network model using fmi & scnsl[END_REF], the authors proposed to use a networking extension of SystemC to develop networked cyber physical systems. No details are given on how SystemC is exported as an FMU. They state that their approach requires that all the cyber models and the network have the same speed, both internally and in terms of communication step size. According to us, this is due to the first FMI limitation we pointed in section V and consequently acknowledge the need for FMI enhancements [START_REF] Krammer | Standard compliant co-simulation models for verification of automotive embedded systems[END_REF] proposed to export a SystemC/SystemC-AMS design as an FMU. This approach diverges from our approach because they use continuous designs written in SystemC-AMS. Consequently they did not study the use of cyber models in the FMI environment. Additionally, unlike us the FMU creation process is not automated but written manually.

Apart from SystemC, there is recently an increasing interest in studying the use of FMI for cyber physical systems. Only few of these approaches study the limitations induced by the use of cyber models in an FMI environment [START_REF] Broman | Determinate composition of fmus for co-simulation[END_REF], [START_REF] Tripakis | Bridging the semantic gap between heterogeneous modeling formalisms and fmi[END_REF], [START_REF] Cremona | Fidean fmi integrated development environment[END_REF], [START_REF] Müller | Linking fmi-based components with discrete event systems[END_REF]. [START_REF] Müller | Linking fmi-based components with discrete event systems[END_REF] is dealing with the import of a Modelica model into the Ptolemy environment [START_REF] Evans | Design and simulation of heterogeneous systems using ptolemy[END_REF]. They co-simulated a discrete event model with a physical model. However in one hand they use FMI for model exchange and not for co-simulation and in the other hand they did not export a discrete event model as an FMU but instead they import the FMU of a physical model into their environment; the problems are consequently different than the one addressed in this paper. orer [START_REF] Broman | Determinate composition of fmus for co-simulation[END_REF], [START_REF] Tripakis | Bridging the semantic gap between heterogeneous modeling formalisms and fmi[END_REF], [START_REF] Cremona | Fidean fmi integrated development environment[END_REF] are a set of correlated papers on 1) the formalization of FMI [START_REF] Broman | Determinate composition of fmus for co-simulation[END_REF], 2) the study of how to bridge the semantic gap between FMI and various other models among which cyber models [START_REF] Tripakis | Bridging the semantic gap between heterogeneous modeling formalisms and fmi[END_REF] and 3) a Ptolemy based environment for heterogeneous co-simulation based on the FMI standard [START_REF] Cremona | Fidean fmi integrated development environment[END_REF]. These interesting papers explain theoretically how some cyber models can be encoded in a way they can be used in an FMI environment. It states some lack on the management of discrete events and propose to add the absent value to FMI in order to deal with discrete event that are not continuous-stated as expected by FMI. While we share the different observations they did, we tried to understand in this paper how to provide a native management of cyber models in FMI, without mangling existing models for this specific purpose. Additionally, we proposed in this paper a new SystemC-RTL FMU exporter.

VII. CONCLUSION & FUTURE WORK

In this paper we studied how FMI manages the use of cyber models in co-simulation mode. This study provides two contributions. The first contribution is an automatic FMU exporter for legacy SystemC RTL designs. An exported SystemC design was co-simulated with a modelica model to ensure the conformance of our FMU with the standard. The second contribution came from the study of the various experiments we did. It is an analysis of some lacks of the FMI standard when co-simulating cyber models with non persistent signal based semantics (in our case SystemC follows a discrete event semantics). We also proposed some solutions to enhance FMI when used in this context.

Many future works can be considered after this study. The first one consider the exporter. We rely now on ScipX, which is an academic tool only suitable to SystemC. We plan to consider other cyber languages like VHDL or Verilog. In this context it can be interesting to use more mature tools like HIFSuite (http://www.hifsuite.com/) to extract the design interface. It is also planned to slightly modify the SystemC library to avoid the cost associated to inter process communications. We also want to implement the new FMI features proposed in this paper. Then, we want to study what information may be exhibited by an FMU in order to automatically reason on causalities in the whole system. Reasoning on such causalities can ultimately lead to the automatic generation of optimized coordinator.

Fig. 1 .

 1 Fig. 1. State-of-the-art approach for co-simulation of a heterogeneous system.

  This SystemC library provides a tracing mechanism based on the Value Change Dump format (VCD), defined by the IEEE Standard 1364-1995 and extended in the IEEE Standard 1364-2001. It generates a VCD file with the entire history of the traced ports/signals of the design.

Fig. 2 .

 2 Fig. 2. The required steps to export a SystemC RTL design as FMU.

Fig. 3 .

 3 Fig. 3. Class diagram our SystemC trace management for FMI.

Fig. 4 .

 4 Fig. 4. A simple example mixing SystemC and Modelica

Fig. 5 .

 5 Fig. 5. CPU time spent for 1 sec. of simulated time as a function of the communication step size.

Fig. 6 .

 6 Fig. 6. Number of integration steps of the FMU solver, for 1 sec. of simulated time as a function of the communication step size.

X means undetermined and Z high impedance


Michelle O Araújo

Ivor Krešić

Robin Kaiser

William Guerin

Superradiance in a Large and Dilute Cloud of Cold Atoms in the Linear-Optics Regime

Keywords: numbers: 32.70.Jz, 42.25.Dd, 42.50.Nn

Superradiance has been extensively studied in the 1970s and 1980s in the regime of superfluorescence, where a large number of atoms are initially excited. Cooperative scattering in the linear-optics regime, or "single-photon superradiance", has been investigated much more recently, and superradiant decay has also been predicted, even for a spherical sample of large extent and low density, where the distance between atoms is much larger than the wavelength. Here, we demonstrate this effect experimentally by directly measuring the decay rate of the off-axis fluorescence of a large and dilute cloud of cold rubidium atoms after the sudden switch-off of a low-intensity laser driving the atomic transition. We show that, at large detuning, the decay rate increases with the on-resonance optical depth. In contrast to forward scattering, the superradiant decay of off-axis fluorescence is suppressed near resonance due to attenuation and multiple-scattering effects.

In his classic paper on coherence in spontaneous radiation by atomic samples [1], Dicke showed that a collection of identical excited atoms could synchronize to emit light coherently. In the case initially envisioned by Dicke, an atomic sample of size small compared to the wavelength of the transition, superradiance can be interpreted as the spontaneous synchronization of the radiation by all atoms and can be understood by the buildup of a giant dipole corresponding to the symmetric superposition of atomic states. Since it is difficult to prepare such dense and small samples, and since near-field dipoledipole interaction may in fact prevent superradiance at high density [2], experimental studies of superradiance in the 1970s and 1980s have been realized with largesize samples (mainly pencil-shaped) of low density [START_REF] Feld | Coherent Nonlinear Optics. Recent Advances[END_REF]4]. In this regime, superradiance, more precisely called superfluorescence [5,6], is intrinsically a nonlinear optical process.

More recently, it has been pointed out that a single photon, first absorbed by one atom among N others in a sample of large size and low density, would be spontaneously emitted in the direction of the initial photon wave vector [7], in contrast with the simple picture of isotropic spontaneous emission. This coherent forward scattering, which has been observed very recently [8], can be explained by a phase-matching condition, and thus does not rely on dipole-dipole interactions. This extendedvolume regime was already mentioned by Dicke [1] and was further developed by others [9,10].

A less obvious result, which does rely on the longrange, light-induced dipole-dipole interactions between atoms, is the decay rate Γ N of the corresponding collective excited state, which has been computed by many authors [9][10][11][12][13][14][15][16][17],

Γ N = C N (kR) 2 Γ , (1)
where Γ -1 is the lifetime of the excited state of a singleatom in vacuum, N is the number of atoms, k = 2π λ is the wave vector associated with the optical transition, R is the radius of the sample, and C is a numerical factor on the order of unity, which depends on the precise geometry of the sample. If the number of atoms is sufficiently large, one can have Γ N ≫ Γ, corresponding to a superradiant decay, even at low spatial density, where the separation between atoms is much larger than the wavelength. This is in contrast with the case of two particles [18][19][20],

for which the single-atom decay rate is recovered for an atomic separation larger than λ. This "single-photon superradiance" has attracted a lot of attention in the last years [21][22][23], but direct experimental evidence has been limited to special geometries involving cavities or waveguides [24,25] or to multilevel schemes [26,27]. Related phenomena are optical precursors [28,29] or "flash" [30][31][32], which can also have a temporal dynamic faster than Γ. Since these effects come from the interference between the scattered field and the driving field, they are only visible in the forward direction and can be explained by the transient response of the complex refractive index of the gas.

On the contrary, light emission at different angles ("offaxis scattering" or "fluorescence") cannot be explained by a phase-matching condition imposed by the initial laser field or a continuous-medium description [33]. Recently, we have used off-axis scattering to observe subradiance [34,35]. In this Letter, we present the direct observation of the superradiant decay of the fluorescence emitted in free space by a large spherical sample of cold atoms, which is continuously driven by a low-intensity laser that is abruptly switched off.

A true single-photon source is indeed not necessary to observe single-photon superradiance. As stressed by Prasad and Glauber [16], it is the spatially extended initial coherence, not entanglement per se, that is fundamentally responsible for cooperative radiation processes such as superradiance and subradiance (see also Refs. [36][37][38]), so that continuous driving by a lowintensity laser (compared to the saturation intensity of the atomic transition) can also be used to study these effects [14,15]. Similarly, it has been shown that the full quantum problem is equivalent, in the linear-optics regime, to classical coupled dipoles [39,40].

Before turning to the experimental results, we use the coupled-dipole model to illustrate the qualitative differences between forward and off-axis scattering. We consider a sample of N motionless two-level atoms distributed over a 3D Gaussian atomic density distribution of rms radius R, illuminated along the z axis by a plane wave (wave vector k 0 = k ẑ) with detuning ∆ = ωω 0 and Rabi frequency Ω ≪ Γ. In the low-intensity limit, using the Markov approximation, the linear response of this many-body system can be simulated by N coupleddipole equations [14,38]

βi = i∆ - Γ 2 β i - iΩ 2 e ik0⋅ri + iΓ 2 i≠j V ij β j , (2)
where β i is the amplitude of the single-excited-atom state i⟩ = g⋯e i ⋯g⟩ and

V ij = e ikrij kr ij , r ij = r i -r j , (3)
describes the light-induced dipole-dipole interaction in the scalar approximation, neglecting near-field terms and polarization effects, which is a good approximation for our dilute samples [41,42]. The first term of the rhs. of Eq. ( 2) corresponds to the natural evolution of the dipoles (oscillation and damping), the second one corresponds to the driving by the external laser, and the last one, the dipole-dipole interaction term, is responsible for cooperative effects.

Numerically solving these equations allows us to compute the emission diagram [38] as well as the temporal decay after switching off the driving term [34,35]. By fitting the initial decay just after the switch off, we can study how the collective decay rate Γ N depends on the emission direction, on the resonant optical depth b 0 = 3N (kR) 2 [START_REF]We use here the definition of b0 corresponding to a vectorial model for light, even[END_REF] and on the detuning ∆. Note that the atom number is limited to a few thousands in the simulations and that the complex Zeeman structure of rubidium atoms is not taken into account, so that a quantitative agreement with the experiment is not expected.

The main results of the numerical study are reported in Fig. 1. At large detuning, the steady state reached before switch off tends to the "driven timed-Dicke state" [7,14,23], in which all atoms have the same excitation probability. As for a collection of independent atoms, the emission diagram is mainly forward directed for large b 0 [inset of Fig. 1(a)], but it also contains a nonnegligible quasi-isotropic background, which is neglected in the continuous-medium approach used in Refs. [11][12][13][14][15][16]. It has also been shown in Ref. [38] that this collective state decays with an initial rate

Γ N = 1 + b 0 12 Γ (4)
for a Gaussian atomic distribution, which is consistent with the scaling of Eq. ( 1) for very large b 0 and with the single-atom limit for small b 0 . We observe this scaling in Fig. 1(b). The slope for the forward scattered light (θ = 0) is very close to the one predicted by Eq. ( 4) because forward scattering is the most important contribution. Moreover, maybe surprisingly, the light scattered off axis exhibits superradiant decay as well [START_REF] Skipetrov | A similar numerical observation has been recently reported[END_REF], with a similar linear scaling with b 0 , the slope being slightly modified by the angle difference [Figs. 1(a) and 1(b)]. Superradiance is thus also visible, and even with a faster decay rate, in the off-axis scattering.

In an experiment, it is hard to use a very large detuning because it obviously decreases the amount of fluorescence. In practice, using a moderate detuning contributes to populate other states than the timed-Dicke state [23], essentially because of the exponential attenuation of the driving field inside the cloud. This contributes to populate longer-lived states, which can be interpreted as subradiant states at large or moderate detuning [35] or simply as radiation trapping due to multiple scattering near resonance [45]. We thus expect that the superradiant decay is suppressed near resonance. This is what we observe in the numerical results of Fig. 1(c) for off-axis scattering. The behavior of forward scattering is different because it is related to the transient response of the refractive index. As shown in [32], it is slightly faster on resonance. These qualitatively different behaviors of forward and off-axis scattering emphasize that the two are different physical mechanisms. Although this is almost never stated clearly, the forward lobe seen in Fig. 1(a) and discussed in many papers (see, e.g., Refs. [8,12,14,46]) should indeed be seen as diffracted and refracted light more than scattered light.

Let us now turn to our experimental observation of superradiance. In our experiment, we load N ≈ 10 9 87 Rb atoms from a background vapor into a magneto-optical trap (MOT) for 50 ms. A compressed MOT (30 ms) period allows for an increased and smooth spatial density with a Gaussian distribution of rms radius R ≈ 1 mm (typical density ρ ≈ 10 11 cm -3 ) and a reduced temperature T ≈ 50 µK. We then switch off the MOT trapping beams and magnetic field gradient and allow for 3 ms of free expansion, used to optically pump all atoms into the upper hyperfine ground state F = 2. Next, we apply a series of 12 pulses of a weak probe beam (waist w = 5.7 mm), linearly polarized and detuned by ∆ from the closed atomic transition F = 2 → F ′ = 3 P/P(0) t/τat t/τat (λ = 780.24 nm and Γ 2π = 6.07 MHz). When we varied the detuning, we also varied the laser intensity accordingly in order to keep the saturation parameter approximately constant at s ≃ (2.2 ± 0.6) × 10 -2 . The pulses of duration 30 µs and separated by 1 ms are obtained by an electro-optical modulator (EOM, fibered Mach-Zehnder intensity modulator by EOspace, Ref. AZ-0K5-10-PFU-SFU-780) with a 90%-10% falltime of about 3 ns (Fig. 2).

It is driven by a pulse generator (DG535 by SRS) and actively locked to avoid any drift of the working point.

In order to improve the extinction ratio, we also use an acousto-optical modulator (AOM) in series with the EOM. Between subsequent pulses of each series, the size of the cloud increases because of thermal expansion, and the atom number decreases due to off resonant optical pumping into the F = 1 hyperfine state during each pulse, which allows us to realize different optical depths within one series of pulses. After this stage of expansion and measurement, the MOT is switched on again and most of the atoms are recaptured. The complete cycle is thus short enough to allow the signal integration over a large number of cycles, typically ∼ 500000. The fluorescence is collected by a lens with a solid angle of ∼ 5 × 10 -2 sr at θ ≈ 35 ○ from the incident direction of the laser beam and detected by a photomultiplier (Hamamatsu HPM R10467U-50). The signal is then recorded on a multichannel scaler (MCS6A by FAST ComTec) with a time bin of 0.4 ns, averaging over the cycles. The cooperativity parameter b 0 corresponding to each pulse is calibrated by an independent measurement of the atom number, cloud size and temperature using absorption imaging (see the Supplemental Material of Ref. [35]). We show in Fig. 2 examples of the measured fluores- cence decay for different values of b 0 and a fixed detuning ∆ = -6Γ. We clearly see that the decay is much faster than the single-atom decay, in contrast to the behavior of collective incoherent scattering effects such as radiation trapping [45]. This fast decay rate increases with b 0 , in line with the expected superradiant behavior. From these data we can fit the initial decay by an exponential and extract the collective decay rate. The fitting procedure has been chosen as follows. The range of the fit starts at t τ at = 0.1, when the probe laser intensity has decayed to 10% of its initial value. It ends when the measured signal arrives at 20% of its initial value or when the background light scattered from the hot Rb vapor in the vacuum chamber is at this level. This background light decays like e -t τat [well visible in the Fig. 2 for P P (0) < 10 -1 ] and has a relative weight that depends on the atom number and the detuning (it is negligible on resonance with the cold atoms and becomes important far from resonance) and which is independently calibrated for each measurement. Finally, when the number of points in the fitting range is less than 15, or when the statistical coefficient of determination of the fit R 2 is less than 0.85, the data are discarded.

The systematic study of the collective decay rate Γ N as a function of the resonant optical thickness b 0 and the detuning ∆ is presented in Fig. 3(a). The increase with b 0 is well visible, especially at large detuning, up to a maximum value Γ max ∼ 5Γ --6Γ, well above the decay rate of independent atoms. We note that the curves acquired for different detunings do not collapse on a single curve, contrary to what has been observed for subradiance [35], showing the sensitivity of superradiance to the proximity of the resonance. Indeed, the decay rates measured for small detunings do not exhibit superradiance, and even at moderate detuning, the decay rate starts to decrease at high b 0 , when the actual optical thickness

b(∆) = g b 0 1 + 4∆ 2 Γ 2 (5)
is on the order of 1 or higher (here g = 7 15 is the relative strength of the transition for a statistical mixture of Zeeman states). We show indeed in Fig. 3(b) that b(∆) becomes the relevant parameter in this regime. These observations are perfectly consistent with the expectation of the coupled-dipole model [Fig. 1(c)] and with the intuition that collective superradiant states are less populated if the driving field is attenuated inside the sample [23].

Finally, we checked that the results are independent of the intensity (or the saturation parameter) to confirm that the experiments have been done in the linear-optics regime. For this we varied the intensity I of the probe beam at fixed detuning and b 0 , and we report in Fig. 3(c) the decay rate as a function of the saturation parameter

s(∆) = g I I sat 1 + 4∆ 2 Γ 2 , (6)
with I sat = 1.6 mW/cm 2 the saturation intensity. We observe no significant variation of Γ N with the saturation parameter in the explored range s < 0.04. In summary, we have reported the first observation of superradiant decay in free space (without a cavity) in the low-intensity regime, using the fluorescence (off-axis scattering) of a cold-atom cloud. We have shown that at large detuning, the decay rate increases with the resonant optical depth, but it is suppressed near resonance. These observations are consistent with numerical solutions of coupled-dipole equations in the dilute limit. The shortening of the radiative lifetime due to cooperativity is potentially important to a number of areas, such as the diagnostics of ultracold gases [47,48], quantum memories [27,49], optical clocks [8,50,51], ultranarrow lasers [52], photon-pair sources [26], and light-harvesting systems [53,54].

To conclude, let us notice that in Dicke superfluorescence [START_REF] Feld | Coherent Nonlinear Optics. Recent Advances[END_REF], in optical precursors (or flash) [32], as well as in the experiment reported here dealing with low-saturation fluorescence, the time scales associated with the transient regimes are always governed by the same cooperativity parameter, the resonant optical depth. These three phenomena can be related to stimulated emission, the refractive index and spontaneous emission, respectively, and are thus different facets of light-atom interaction. It is interesting, and also beautiful, to see that they exhibit cooperativity in a similar way. On the other hand, other collective properties, such as the cw susceptibility (including the refractive index, the linear attenuation coefficient or gain coefficient for inverted systems, the Lorentz-Lorenz shift [55], and beyond mean-field corrections [56,57]) and weak-localization corrections to diffusive transport [58], are governed by the atomic density. The fundamental difference is that the latter are properties of the bulk material, which can be defined for an infinite medium. Transient phenomena, on the contrary, involve light escaping from the sample, in which case the finite size of the medium and the finite number of atoms are necessarily key parameters [59].

5 FIG. 1 .

 51 FIG.1. Numerical study of the initial collective decay rate Γ N . (a) Temporal evolution of the fluorescence after the switch off of the driving laser at t = 0, with b0 = 11.3, ρ0λ 3 = 4.6, ∆ = 10Γ, averaged over 50 configurations, for two different angles, in the forward direction θ = 0 and at 90 ○ (θ = π 2). The amplitude is normalized to the steady state amplitude, which is much larger for θ = 0 as shown in the emission diagram (inset, in log scale). The time axis is normalized to the lifetime of the excited state τat = Γ -1 ≈ 26 ns. An exponential fit in the range 0 < t τat ≤ 0.2 allows us to extract the initial decay rate Γ N . At late time, the decay becomes subradiant[34,35]. The dashed line shows the decay expected for a single atom (rate Γ). (b) Decay rate as a function of the resonant optical thickness b0 = 3N (kR) 2 for different densities (ρ0 is the density at the center of the cloud). Filled symbols are for θ = 0 and open symbols for θ = π 2. The increase is mainly linear in b0. The slope of the linear increase slightly depends on the angle. The dotted line shows the expectation for the decay of the timed-Dicke state [Eq. (4)]. (c) Decay rate as a function of the detuning, for b0 = 17, ρ0λ 3 = 4.6 and detection angles θ = 0, π 2. Off-axis superradiance is suppressed near resonance. The error bars shown in panel (c) and omitted in panel (b) for clarity correspond to the 95% confidence interval for the exponential fit of the decay rate.

5 FIG. 2 .

 52 FIG. 2. (a)Decay of the measured fluorescence power P switching off the probe laser for two different b0 (red and blue solid lines) at a given detuning ∆ = -6Γ. The vertical axis is normalized to the steady-state fluorescence level. The dashed line shows the expected decay for a single atom, e -t τ at , and the black solid line is the switch off of the laser (the fast part with a poor extinction ratio is due to the EOM and the slower part is due to the AOM). (b) Same data at shorter time scales, with the exponential fit of the initial decay that allows us to measure Γ N .

FIG. 3 .

 3 FIG. 3. Experimental study of the initial collective decay rate Γ N . (a) Systematic analysis of Γ N as a function of the resonance optical thickness b0 and the detuning ∆. (b) Same data shown as a function of b(∆). When b(∆) ≳ 1, it becomes the scaling parameter. (c) Γ N as a function of the saturation parameter s(∆), for b0 = 21 ± 1 and ∆ = -4Γ. In all panels, error bars represent the 95% confidence interval of the fit.

We thank R. Bachelard and N. Piovella for fruitful discussions. We acknowledge financial support from the CNRS international program, the French Agence National pour la Recherche (Project LOVE, No. ANR-14-CE26-0032), the Brazilian Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES), the Brazilian Conselho Nacional de Desenvolvimento Científico e Tecnológico (CNPq, Project PVE, No. 303426/2014-4), and the European Research Executive Agency (Program COSCALI, No. PIRSES-GA-2010-268717).

Note added.-Recently, we have learned of a complementary experiment on superradiance in for forward direction; see Ref. [60].