Hybrid fire testing using FMI-based co-simulation

a


Background and motivation
The failure mode of a structural component subjected to fire loading is sensitive to its Boundary Conditions (BCs).For example, thermally induced buckling of a restrained column exposed to fire might occur or not, depending on the stiffness of the connected structural system.However, the common situation in standard fire testing is that the experimenter has limited control of the BCs of the tested specimen.For example, a column can be easily tested with either fixed or pinned ends but not with any intermediate flexible restraint [1].Hybrid Fire Testing (HFT) has been developed to overcome this limitation.HFT is carried out using a hybrid model that combines Physical and Numerical Substructures (PS and NS, respectively).The PS is enclosed in a furnace or exposed to a heat source, while servo-controlled actuators equipped with force transducers control mechanical BCs.Specifically, actuator position setpoints (or force setpoints) are adjusted to ensure force equilibrium and displacement compatibility with the NS, which is simulated using, for example, a Finite Element Analysis (FEA) software such as SAFIR [2].Accordingly, the NS is crafted to provide some desired BCs that the PS shall experience while being exposed to fire loading.
Mechanical and thermal actuation plus feedback transducers form the transfer system while the algorithm that updates actuator setpoints based on PS and NS responses on the fly is indicated as coordination algorithm.For a comprehensive state-of-art review of HFT, the reader is addressed to [3].
In order to reduce the effort associated with the coupling of experimental equipment and simulation software to enable hybrid testing, several middlewares have been developed.Remarkable work has been carried out in the domain of earthquake engineering, where hybrid testing was pioneered [4].An incomplete list of middleware packages includes, in chronological order of appearance, UI-SimCor [5], Online Hybrid Test System [6], ISEE [7,8], Open-Fresco [9], HybridFEM [10], CELESTINA [11], UT-SIM [12], and JRC-ELSA framework [13].The use of Open-Fresco as a middleware for HFT is demonstrated in [14,15] while the use of UT-SIM for the purpose of HFT is demonstrated in [16,17].If one intends to enable the use of a new component (e.g., simulation software or control system) in HFT, a specific extension must be programmed for every supported middleware.Ideally, such effort shall be sustained once.However, this requires standardizing all interfaces of all software components involved in HFT.The challenge of improving the interoperability of simulation tools and control systems for the https://doi.org/10.1016/j.firesaf.2023.103832Received 24 October 2022; Received in revised form 27 February 2023; Accepted 28 May 2023 purpose of hybrid testing was raised for the first time by Huang & Kwon [12], who proposed a framework called UT-SIM.UT-SIM relies on TCP/UDP protocols to establish communication between PS, NS, and coordination algorithm.The data exchange format was formulated based on a pool of existing middlewares.UT-SIM has been applied to perform HFT of a stiff steel column subjected to axial load and enclosed into a furnace (PS and transfer system) coupled with a frame FEA model implemented in Abaqus [18] (NS) [16,17].
As identified by Huang & Kwon [12], interoperability of simulation tools is necessary to facilitate the implementation of HFT.However, to exchange hybrid models across laboratories, portability of simulation tools is as critical as their interoperability.A crucial motivation for that is the round-robin verification of HFT experiments.In experimental methodology, a round-robin verification consists of a pool of laboratories performing the same experiment independently and crossvalidating their results.To enable round-robin verification campaigns, a pool of laboratories shall be able to deploy the same hybrid model regardless of its specific software infrastructure (specific release of simulation tools and middleware).
The Functional Mock-up Interface (FMI) standard, originally introduced in the automotive sector to craft complex vehicle Co-Simulations by coupling domain-specific simulation environments [19,20] is a viable solution for crafting portable hybrid models.Specifically, the FMI standard defines how to encapsulate simulation models into standardized containers to form Functional Mock-up Units (FMUs) [21], which are coupled in a Co-Simulation through standard interfaces.However, to the authors' knowledge, FMI-based Co-Simulation is not yet exploited to support HFT.

Scope
The FMI standard is organized under the roof of the Modelica Association [22].The institutionalization of the FMI standard dates back to 2011 (onset of Industry 4.0 revolution) when the Modelica Association [22] was funded as an outcome of the Modelisar ITEA-2 project [23] led by the automotive industry.As of today, the FMI standard is officially supported by +170 simulation tools [24] and provides templates for supporting FMU import/export in several programming languages.In essence, the FMI standard defines interface and container specifications that an FMU must comply with to be linked with other FMUs within a Co-Simulation [19,21].In practice, an FMU is a *.ZIP file that encapsulates either the binaries of a simulation model (e.g., an FEA model) or the Application Programming Interface (API) necessary to communicate with a physical system (e.g., a control system), and an *.XML file describing the FMU input/output variables.
The FMU API follows the FMI standard and includes an (i) init() method that initializes the FMU, a (ii) doStep() method that solves a single analysis step and (iii) set() and get() methods that read/write output/input variables.An FMU can be either generated using the FMU exporter of specific simulation software -when available -or programmed directly using existing software libraries such as Moka [25] and UniFMU [26].In order to check that FMUs comply with the FMI standard it is possible to use VDMCheck [27].
Co-Simulation is executed by an orchestrator, which is a computer program that initializes all the FMUs and coordinates their execution and data exchange following the specific Co-Simulation scenario.Specifically, the Co-Simulation scenario describes the inter-connections between input and output variables of each FMU while the orchestrator software enforces these input-output relationships at each step of the Co-Simulation using a numerical solver for nonlinear algebraic equations (e.g., based on Jacobi or Gauss-Seidel algorithm) [28,29].Gomes et al. [20,30] provides a broad overview of Co-Simulation.
Because of its inherent modularity and compartmental structure, FMI-based Co-Simulation is an efficient framework for coupling PS and NS of a hybrid model in HFT.However, some constraints associated with the FMI standard render some implementation choices preferable to others.To the authors' knowledge, a comprehensive account in this regard is still missing.It follows that the original contribution of this paper is a methodology for crafting FMUs and Co-Simulation scenario for the purpose of HFT.
The paper is organized as follows.Section 2 presents the Co-Simulation-based HFT framework.First, the HFT concept, along with a mathematical description of the hybrid model, is illustrated.Then, the methodology for crafting FMUs and Co-Simulation scenario for HFT with one PS and one NS and a generic coordination algorithm is demonstrated.Section 3 describes the experimental validation of the proposed methodology using a single-Degree-of-Freedom (single-DoF) hybrid model.FMUs are crafted for two different coordination algorithms taken from the state of the art [31,32].The orchestrator software Maestro [33] developed by the research group of Cyber-Physical Systems of Aarhus University, Denmark, is utilized to conduct Co-Simulation.Section 4 summarizes the findings of this study.

Hybrid model equations
The mechanical response of a structural system exposed to fire loading is typically quasi-static.Therefore, the hybrid model response can be described by a static equilibrium equation with a reasonable degree of approximation.The following set of equations expresses the static equilibrium of a multiple-DoFs hybrid model and the compatibility of displacements at the interface of PS and NS, where    (  ,   ()) and    (  ,   ()) are the internal restoring force vectors of the PS and the NS, subjected to the corresponding displacement (  ,   ) and temperature fields (  (),   ());    () and    () are the vectors of externally applied loading; , is the vector of interface forces that couple PS and NS;   and   are signed Boolean collocation matrices used to cast interface compatibility and equilibrium equation consistently [34].It is important to remark that memory variables associated with the internal restoring forces, which account for memory effects such as hysteresis, are purposely omitted.The reason is that such variables are not exchanged among the various component of the HFT.
For the sake of simplicity and, as often done in HFT, both PS and NS equilibrium equations are condensed to the coupled DoFs.It follows that the signed Boolean matrices reduce to and where  is the identity matrix.For this specific case, the equilibrium equation of the hybrid model reported in (1) becomes In order to simplify the description of FMI-based HFT, it is convenient to reformulate (4) as, where PS and NS unbalanced forces are defined as, As one can notice from ( 6), the time dependency of the unbalanced forces   (, ) and   (, ) hides the time-dependency of temperature field and externally applied loading for each substructure.The majority of coordination algorithms have been developed for displacement-control mode HFT.In principle, the coordination algorithm updates  until the norm of ( 5) is less of a given tolerance.A few exceptions are the procedures presented in [35], and [36], which perform HFT in force-control mode.Also, coordination algorithms can be categorized in two groups, namely control-based and simulation-based coordination algorithms.The control-based group contains all coordination algorithms obtained as the solution to a control system design problem.The coordination algorithms presented in [31,[36][37][38] belong to this category.The simulation-based group contains all coordination algorithms obtained from numerical solvers for systems of nonlinear differential/algebraic equations.The coordination algorithms presented in [14,16,17,32,[39][40][41] belong to this category.As displacement-control mode HFT is the dominant setting, this paper demonstrates Co-Simulation-based HFT for this specific case considering both a control-based and a simulation-based coordination algorithm taken from the state of the art [31,32].

FMUs and Co-Simulation scenario
The block diagram of Fig. 1 illustrates the Co-Simulation-based HFT concept for a hybrid model comprising one PS and one NS.In detail, the P-FMU incorporates the API to the test setup hosting the PS, while the N-FMU incorporates the simulation model utilized as NS.As HFT is performed in displacement-control mode, both P-FMU and N-FMU receive displacements as input variables  (•) and produce unbalanced forces as output variables  (•) .If the solution algorithm utilized to compute the NS response or the control algorithm utilized to compute the PS BCs requires additional state variables, they are stored in vector  (•) .Vector  (•) contains all constant parameters.As an example, if some of the PS DoFs are loaded but not included in the HFT simulation loop,   stores the parameters defining the BC histories applied to such DoFs.The HFT coordination algorithm is implemented as an additional FMU, namely the C-FMU.As HFT is performed in displacement-control mode, the C-FMU receives unbalanced forces as input variables   and produces displacement as output variable   .Additional state variables and constant parameters utilized by the coordination algorithms are stored in   and   , respectively.At the Co-Simulation start, the orchestrator executes the init() method of each FMU once so that  (•) ,  (•) ,  (•)   and  (•) are initialized.At each time step, the orchestrator executes the doStep() method of each FMU to carry out one analysis step.
Then, the orchestrator transfers data according to the input-output relationships encoded in the Co-Simulation scenario.The procedure requires one iteration to enforce the input-output relationships specified by the Co-Simulation scenario.Then, the Co-Simulation moves to the next analysis step.The proposed methodology does not alter the inner workings of the specific coordination algorithm.Therefore, if a given coordination algorithm is endowed with proof of validation, one can confidently adopt it in the present FMI-based implementation.For the Co-Simulation scenario illustrated in Fig. 1, special attention must be paid to the algebraic dependencies introduced by the coordination algorithm.Noteworthy, the doStep method of the C-FMU must be invoked after having provided the new inputs, originating from the outputs of the already stepped P-FMU and N-FMU.The consequence is that the Co-Simulation framework must accept a description of the ordering in which the FMUs shall be stepped [42][43][44][45].The FMI standard 2.0 offers no such mechanism, which is, nevertheless, implemented in Maestro [33], the orchestrator adopted in this study.In addition, based on the Co-Simulation scenario and the specifications of each single FMU, Maestro uses formal methods to verify, for example, that the execution of FMUs does not violate causality or that exchanged signals have consistent units.Warning/error messages are generated accordingly [46].Maestro is supported and maintained by the INTO-CPS non-for-profit association [47].A number of alternative packages exist, and an incomplete list of similar projects includes Coral, DACCOSIM, and FMIGo [48].
The need for supporting a large number of simulation tools has made the FMI standard extremely versatile.The consequence is that one can adopt alternative strategies to craft the same Co-Simulation, some of which are more efficient than others.
The overall philosophy of Co-Simulation is that the orchestrator schedules the execution of the FMUs and enforces their input/output relationships as listed in the scenario.It follows that the orchestrator typically allows for little customization [49,50].In the preliminary stage of this study, the coordination algorithm was implemented in the orchestrator, Maestro, which is written in Java.Java is designed to enable the development of portable, high-performance applications for the widest range of computing platforms possible.Platform independency is not the sole reason behind the selection of Java.Java is a strongly typed and object oriented programming language, which means that it demands the declaration of each variable with a data type that cannot be changed dynamically.This feature is crucial to implement formal methods for model verification.However, Java is inefficient for the matrix computations involved in numerical analysis.It follows that the authors abandoned this approach in favor of implementing the coordination algorithm into a dedicated FMU, namely, the C-FMU using the Python template provided by UniFMU [26].Furthermore, this approach allows the user to swap the coordination algorithm of the hybrid model easily.

Hybrid model
The experimental case study utilized to demonstrate the proposed framework consists of a single-DoF hybrid model where a 3D printed cantilever beam made of Polylactic Acid (PLA) (PS) is coupled with a linear elastic spring (NS).The PS is exposed to a heat source, whereas the NS is cold.The single-DoF hybrid model is subjected to a sinusoidal force, which produces a cyclic displacement response.The hybrid model is schematically depicted in Fig. 2(a) while the experimental setup with the PS installed is reported in Fig. 2(b).
As can be appreciated from Fig. 2(b), a mini linear electric actuator (50 mm stroke, 200 N force capacity) control the PS deflection.The actuator is fixed to a force transducer that measures the restoring force, whereas an internal resolver measures the position.Another PLA block provides fixation to the force transducer and, therefore, to the actuator.Both displacement-and force-control modes are possible for the actuator.Thermal loading is applied to the PS using a 26 Ohm wire resistor supplied with 5 V through a digital switch.Four digital temperature sensors measure the PS temperature response.An Arduino Nano R3 board runs the bang-bang controllers [51] of both the actuator and wire resistor.A Windows PC sends the actuator position/force setpoint and the temperature setpoint to the Arduino board using a serial interface implemented in Python.Using a pair of switches, one can manually adjust the actuator position inwards and outwards to facilitate the installation of the specimen.Similarly, the temperature setpoint can be adjusted using a potentiometer.
HFT is implemented in displacement-control mode.Therefore both N-FMU and P-FMU receive a displacement command as input and send corresponding unbalanced forces as output.In both cases, FMUs are implemented as Python scripts using UniFMU [26].In the N-FMU, the unbalanced force is computed as, where   is the stiffness of the NS,  the displacement and   () is the externally applied loading as defined in Fig. 2(a).The P-FMU wraps the Python interface to the Arduino board, which receives displacement and temperature setpoints and feeds the corresponding response signals back.The PS restoring force is corrected as suggested in [52] to compensate for limited actuation accuracy.The expression of the unbalanced force reads, where   and   , are the displacement and restoring force measured from the PS, and   is an estimate of the PS tangent stiffness obtained with small displacement perturbations in cold conditions.
In order to promote the dissemination of HFT, the experimental setup has been purposely designed to fit a 150 × 300 mm plate and relies on cheap standard electronics available out-of-shelf.All remaining parts are 3D printed.The full documentation of the project, including the schematic of the Arduino board, the list of components, the geometry files for 3D printing, and the source code, are available at [53].The authors deem it important to remark that the choice of crafting an application example characterized by a single-DoF PS is meant to facilitate the reader in reproducing the experiment independently with little budget.However, the methodology presented in Section 2 is not limited to single-DoF hybrid models.

Coupling FMUs
In the following, the Co-Simulation-based implementation of HFT is illustrated for the control-based coordination algorithm of Mergny et al. [31], and a monolithic variant of the simulation-based coordination algorithm of Abbiati et al. [32].Both algorithms are conceived for HFT in displacement-control mode and are illustrated to solve the equilibrium equation of the hybrid model as formulated in (4).To simplify the notation, displacement, and time dependencies in  (•) (, ) are omitted hereinafter.

Control-based coordination algorithm
The selected control-based HFT algorithm is the one proposed by Mergny et al. [31].The algorithm consists of a PI controller designed to minimize unbalanced forces between PS and NS while displacement compatibility is assumed a priori.The procedure for computing the hybrid model response from   to  +1 using a time step  =  +1 −   is reported as a sequence of steps: 1. Compute the displacement command at  +1 as where   and   are gain matrices for the instantaneous interface force unbalance error   and the corresponding integral   .2. Evaluate the corresponding unbalanced forces for both NS and PS as +1 is numerically evaluated by solving the static response of the NS subjected to the displacement field  +1 and the temperature field   +1 , e.g., using a FEA software.  +1 is experimentally measured after imposing the displacement field  +1 and the temperature field   +1 to the PS using the transfer system.3. Compute the instantaneous residual force  +1 and update the corresponding integral  +1 as The described procedure loops from (1) to (3) until the end of the loading sequence.In [31], it is proposed to compute gain matrices as where The NS stiffness matrix   is estimated numerically, whereas the PS stiffness matrix   is experimentally measured by applying small displacement perturbations to the specimen.The parameters   ,   ∈ [0, 1] are used to modulate the controller gain.In the proposed implementation, the init() methods of P-FMU and N-FMU save the tangent stiffness matrices of the PS and the NS and are executed before the init() method of the C-FMU.The latter reads such matrices and computes the gain matrices   and   .A block diagram of the C-FMU obtained from the control-based coordination algorithm of [31] is reported in Fig. 3.

Simulation-based coordination algorithm
The selected simulation-based HFT coordination algorithm is a monolithic variant of the time integration scheme proposed by Abbiati et al. [32].The algorithm coincides with the dynamic relaxation method described in [54].The basic idea behind dynamic relaxation is to obtain the displacement solution of a static structural problem by computing the transient response of an equivalent dynamic system, whose equation of motion reads, where  and  are fictitious mass and damping diagonal matrices computed as   = 2 0   (19) where   is a generic entry of the initial tangent stiffness of the hybrid model  =   +   as defined in (16), and  0 is the lowest undamped frequency associated with the matrix pair {, } while  is the time step size of the equivalent transient analysis.The central difference algorithm, which is equivalent to the Newmark algorithm [55] with  =1 2 and  = 0, is used to solve (17).The procedure for computing the hybrid model response from   to  +1 using a time step  =  +1 −  is reported as a sequence of steps: 1. Compute displacement and pseudo-velocity vectors using Newmark's extrapolation equations 2. Evaluate the corresponding unbalanced forces for both NS and PS as +1 is numerically evaluated by solving the static response of the NS subjected to the displacement field  +1 and the temperature field   +1 , e.g., using a FEA software.  +1 is experimentally measured after imposing the displacement field  +1 and the temperature field   +1 to the PS using the transfer system. 1

Compute the pseudo-acceleration vector at 𝑡
with computed and inverted once before the HFT. 4. Update the pseudo-velocity vector based on the computed pseudo-acceleration vector The described procedure loops from (1) to (4) until the end of the loading sequence.
The expression of   forces the upper bound   of the eigenfrequencies associated with the matrix pair {, } to be slightly smaller than   = 2∕, which defines the stability limit of the central-difference method.Specifically, the upper bound   is defined upon Gershgorin's circle theorem [56].It is well known that the rate of convergence of the dynamic relaxation method deteriorates when  0 ∕  ≪ 1.Therefore, in [32], dynamic relaxation is used in combination with model-order reduction.In the proposed implementation, the init() methods of P-FMU and N-FMU save the tangent stiffness matrices of the PS and the NS.The init() method of the C-FMU is executed afterward and reads such matrices and computes the dynamic tangent stiffness matrix  and the fictitious damping matrix  utilized by the coordination algorithm.A block diagram of the C-FMU obtained from the simulation-based coordination algorithm of [32] is reported in Fig. 4.

Results and discussion
Table 1 provides an overview of the performed HFTs.As can be appreciated, for all tests, a sinusoidal force of 16 N amplitude is applied as mechanical loading and equally distributed between PS and NS.With regard to thermal loading, Test #1 is exposed to a power source () of 1.0 W for the entire test, resulting in a parabolic-like timetemperature response.Tests #2 and #3 are performed by imposing to the PS a linear temperature ramp from 22 • C (room temperature) to 50 • C with temperature rate θ() = 7.5 × 10 −3 • C/s.Fig. 5 collects all experimental results related to Test #1, namely, displacement, The main difference between Test #1 and the other two tests is that, during Test #1, the relay module was constantly on to deliver constant electric power to the wire resistor.In contrast, during Tests #2 and #3, the temperature controller switched the relay on and off approximately every 2 s to track the linear temperature ramp.As the time allocated to the experimental campaign was limited, the malfunctioning of the force transducer was not fully resolved.However, the most plausible explanation is that the relatively fast switching of the relay caused some electric disturbance to the force transducer, which produced a wrong measurement at the systematic value of ≈ −55.0 N.
Instead of discarding these results, they have been reported as they provide a deep insight into the behavior of the two coordination algorithms under stress testing.As can be appreciated from Fig. 6, during Test #2, which utilizes the control-based HFT algorithm of [31], the sudden force perturbation is damped out almost instantaneously.A very similar perturbation in Test #3, which is carried out with the simulation-based HFT algorithm of [32], is damped out after a few displacement cycles as demonstrated in Fig. 7.It is reasonable to conclude that the control-based HFT algorithm shows better performance in terms of disturbance rejection.

Conclusions
A hybrid fire testing experiment cannot be easily reproduced in two different laboratories if they use different middlewares and simulation tools.An important consequence is that the feasibility of round-robin verification hybrid fire testing experiments is limited.In response to this limitation, this paper proposes a methodology for conducting hybrid fire testing using Co-Simulation as framed by the Functional Mock-up Interface standard.Specifically, the methodology defines how to partition the hybrid model into functional mock-up units for the physical substructure, the numerical substructure, and the coordination algorithm.The methodology is demonstrated for an Arduino-based experimental case study characterized by a single degree of freedom considering two existing coordination algorithms.The same methodology is valid for multiple-degrees-of-freedom hybrid models.The advantage of implementing the coordination algorithm as a functional mock-up unit is that the coordination algorithm is disentangled from the orchestrator.Therefore, the user can swap the coordination algorithm more

Fig. 1 .
Fig. 1.Block diagram of Co-Simulation HFT considering one PS and one NS.

G
.Abbiati et al.

Fig. 3 .
Fig. 3. Block diagram of the C-FMU implementation of HFT based on the control-based coordination algorithm of [31].

Fig. 4 .
Fig. 4. Block diagram of the C-FMU implementation of HFT based on the simulation-based coordination algorithm of [32].

Table 1
List of HFT experiments.As one can see, in both experiments, a sudden force peak occurred at about ≈ 1670 s in Test #2 and ≈ 970 s in Test #3, respectively.After examining the PS force response history acquired through the force transducer, it was observed that, in both Test #2 and Test #3, suddenly, the force measurement jumped to ≈ −55.0 N.These sudden force peaks, which did not occur in Test #1, propagated to the displacement computed by the HFT algorithm in the subsequent time step.In order to understand the cause of the restoring force peaks, 5-6 additional tests have been conducted for each of the settings characterizing Test #1, #2, and #3.The same sudden restoring force peak of ≈ −55.0 N systematically occurred for all tests with the same setting of Test #2 and #3 at a random point in time, whereas, the same restoring force peak did not manifest in all tests conducted with the same setting of Test #1.