Ghazaleh Khodabandelou
email: ghazaleh.khodabandelou@malix.univ-paris1.fr

Charlotte Hug
email: charlotte.hug@univ-paris1.fr

Rébecca Deneckère
email: rebecca.deneckere@univ-paris1.fr

Camille Salinesi
email: camille.salinesi@univ-paris1.fr

Unsupervised Discovery of Intentional Process Models from Event Logs

Keywords: Software Development Process, Intentional Process Modeling, Event logs Mining

Research on guidance and method engineering has highlighted that many method engineering issues, such as lack of flexibility or adaptation, are solved more effectively when intentions are explicitly specified. However, software engineering process models are most often described in terms of sequences of activities. This paper presents a novel approach, so-called Map Miner Method (MMM), designed to automate the construction of intentional process models from process logs. To do so, MMM uses Hidden Markov Models to model users' activities logs in terms of users' strategies. MMM also infers users' intentions and constructs fine-grained and coarse-grained intentional process models with respect to the Map metamodel syntax (i.e., metamodel that specifies intentions and strategies of process actors). These models are obtained by optimizing a new precision-fitness metric. The result is a software engineering method process specification aligned with state of the art of method engineering approaches. As a case study, the MMM is used to mine the intentional process associated to the Eclipse platform usage. Observations show that the obtained intentional process model offers a new understanding of software processes, and could readily be used for recommender systems.

INTRODUCTION

Fueled by the growing presence of events logs in software and software engineering platforms, process mining has emerged a few years ago as a key approach to design software processes [START_REF] Rozinat | Towards an evaluation framework for process mining algorithms[END_REF][START_REF] Van Der Aalst | Workflow mining: Discovering process models from event logs[END_REF][START_REF] Van Der Aalst | Process mining: discovery, conformance and enhancement of business processes[END_REF]. Mining software engineering processes from logs can be useful for understanding how people really work, analyzing how actual software engineering processes differ from the prescribed ones, and thereby improve software engineering methods and products. Whereas most process mining approaches specify behaviors in terms of sequences of tasks and branching, we believe that the fundamental nature of processes is mostly intentional. Intentionoriented software process specification has been promoted since long ago. In the 80s, intentional models were proposed in the IS community as a potential theoretical foundation to determine users' behavior [START_REF] Davis | User acceptance of computer technology: a comparison of two theoretical models[END_REF] or in a former work to model humans behavioral intention, particularly for computer usage behavior [START_REF] Ajzen | Attitude-behavior relations: A theoretical analysis and review of empirical research[END_REF]. Later on, in the early 90s, intention analysis and modeling have been promoted as a driving paradigm to study strategic alignment, to define actors and roles [START_REF] Yu | Modelling strategic relationships for process reengineering[END_REF], to guide requirements elicitation [START_REF] Rolland | Modeling the requirements engineering process[END_REF], to handle traceability [START_REF] Jarke | Establishing visions in context: towards a model of requirements processes[END_REF], to study users behavior to identify and name use cases, etc. Representing processes by intentions and strategies has proved a powerful tool to better understand the deep nature of processes, to see how processes interweave and combine, to abstract processes and visualize them under man-manageable form, even when they are extremely complex [START_REF] Rolland | Modeling goals and reasoning with them[END_REF].

This paper presents a method, so-called Map Miner Method (MMM) that aims at discovering users' intentions and strategies to construct intentional process models from event logs. MMM generates intentional models specified with the Map notation [START_REF] Rolland | A multi-model view of process modelling[END_REF][START_REF] Rolland | Modeling goals and reasoning with them[END_REF]. This notation is chosen rather than other intentional process models such as KAOS or I* [START_REF] Yu | Modelling strategic relationships for process reengineering[END_REF][START_REF] Dardenne | Goal-directed requirements acquisition[END_REF] because (a) it has already proved effective for specifying software engineering processes [START_REF] Rolland | Modeling the requirements engineering process[END_REF], (b) it supports process variability and multi-process specification [START_REF] Rolland | A multi-model view of process modelling[END_REF], and (c) its way of combining intentions and strategies at multiple levels of abstraction scales well to large and complex processes [START_REF] Rolland | Modeling goals and reasoning with them[END_REF]. In MMM framework, an intention is defined as a goal, an objective or a motivation to achieve a goal with a clear-cut criteria of satisfaction, which can be fulfilled by the enactment of a process [START_REF] Soffer | Combining intention-oriented and state-based process modeling[END_REF]. The intentions are explicitly represented and are of high-level of abstraction (e.g., organizational goals).

In software engineering context, MMM can be useful at different stages of the process model life-cycle, for instance: (i) at the requirements level, to understand users intentions from software usage activity logs; (ii) at the project management level, to check alignment between prescribed process models and what stakeholders actually do; or (iii) at the application level, to monitor users and provide run-time recommendations.

The contribution made in this paper is triple: (i) First, modeling the users' activities logs in terms of strategies (using Hidden Markov Models (HMMs) [START_REF] Rabiner | An introduction to hidden markov models[END_REF]); unsupervised learning is used to estimate the parameters of HMM, (ii) Second, using estimated strategies and Map formalism, we develop Deep Miner and Map Miner algorithms to generate respectively, fine-grained and coarse-grained Map process model, (iii) Finally, the entire proposed approach is applied on two practical datasets; first in a laboratory context, second in a large-scale case study by mining the Eclipse UDC (Usage Data Collector) developers' logs [START_REF]Filtered udc data[END_REF]. The resulting Maps provided a precious understanding of the processes followed by the students and the developers, and some feedback on the effectiveness and scalability of MMM.

The remainder of this paper is organized as follows. Section 2 introduces MMM, which consists in modeling users' activities in terms of strategies (using HMMs). This section also describes Deep Miner and Map Miner algorithms. Section 3 describes the application of MMM on a dataset resulting from the event logs of Entity/Relationship diagrams creation. Section 4 represents the large-scale case study with event logs from Eclipse UDC to find out how developers use the Eclipse technology. Related works are discussed in section 5 and threats to validity in section 6. Finally, section 7 concludes this work and presents its perspectives.

MAP MINER METHOD

The key idea of MMM is modeling the users' behaviors in terms of their underlying intentions and strategies, from event logs. The strategies are the alternative ways to fulfill the intentions. MMM uses the Map metamodel to model actual process followed by users. According to the Map meta model, intentions express what users intend to perform during the enactment of a process [START_REF] Rolland | A multi-model view of process modelling[END_REF]. In other words, the enactment of a process is the execution of a sequence of activities that are caused by users' intention. According to the fuzzy mechanism of a cognitive process, several intentions cause the performance of several activities at the same time. However, the intentions are not directly related to the activities; the intentions can be fulfilled by combining different activities, which are different ways of achieving an intention, i.e., strategies. Indeed, in the Map metamodel, strategies are used to move from one intention to another and are made of one or several activities. This relationship between the intentions, the strategies and the activities, represents the top-down structure of reasoning and acting in cognitive processes of human brain. Nevertheless, only the low-level part of this structure, i.e., users' activities, is observable. The middle and high-level part (strategies and intentions) are abstract notions and therefore unobservable directly. MMM proposes to trace back this structure to achieve the sources, which are users' intentions. It is important to define some notions used in this paper. The notion of intention is defined in the introduction. However, there are also sub-intentions, which are the low-level intentions. They are the finest intentional objects of the Map metamodel. Each sub-intention is associated to a parent intention, and one intention is fulfilled if at least one of its children sub-intention is fulfilled. The sub-intentions allow obtaining the fine-grained Map and the intentions allow obtaining the coarse-grained Map.

MMM uses the observable users' activities traces (a set of event logs), generated while interacting with Information Systems. MMM consists of three phases: (i) First phase: estimating the users' strategies from observed activities using HMMs. The topology of HMM permits modeling observed process (users' activities) in terms of hidden states (underlying users' strategies), (ii) Second phase: generating fine-grained Map process model using estimated strategies along with Map formalism (Deep Miner algorithm), (iii) Final phase: generating coarse-grained Map process model from fine-grained one (Map Miner algorithm). Constructing the Map process model thereby allows rebuilding the actual process model, i.e., the model followed by users. Figure 1 depicts an overview of MMM.

Before addressing the problem of discovering a Map, the associated framework is briefly explained in the following section.

Map Metamodel

Map is an intentional process metamodel. Map process model (an instance of Map metamodel) allows representing process models in terms of users' intentions and strategies. Figure 2 illustrates a Map process model where the nodes represent the intentions and the edges represent the strategies. A set of <Source Intention, Strategy, Target Inten-tion> represents a section in the Map. Map allows representing flexible process models, enacted in a dynamic way since the sections of a Map can be executed non-sequentially and as long as intentions are not completely fulfilled. For example, on figure 2, one way to fulfill the intention Specify an entity is to select the strategy S4: By generalization which is composed of two activities: create an entity and create generalization link (see Table 1). Thus, confronted to a specific situation and a particular intention, the Map reveals the alternative strategies to fulfill the intention. The corresponding section of this example is <Specify an entity, By generalization, Specify an entity>.

Specify an entity

Specify an association

Estimating Strategies from Activities

HMMs allow modeling the structure of complex temporal dependencies between two complementary Markov processes: hidden and observed processes, given that the observed process is generated depending on the state of the hidden process. Generally, the states of hidden process are not visible but the probability of a given state can be inferred by computing the Maximum Likelihood of the observed process. The two complementary processes are defined next.

Hidden Process: Users' Strategies

Let s " ps1, . . . , sLq P S L be a temporal sequence of users' strategies of length L. The topology M1 is chosen for hidden process, which means that the strategy s l at step l only depends on the strategy at step ℓ ´1. This choice is justified by the fact that strategies are performed in a logical order by users. A homogeneous Markov chain, which parameters are denoted by T and π, models the hidden process (strategies) with:

Tpu, vq " Pr ps ℓ " v|s ℓ´1 " uq @u, v P S, ℓ P r2, Ls, πpuq " Pr ps1 " uq @u P S.

(

) 1
The vector π contains the probabilities of strategy at the initial state and the matrix T contains the transition probabilities for the following strategies, i.e., the transition probabilities from any strategy at step ℓ´1 to any other strategy at step ℓ (including itself).

Observed Process: Users' Activities

Let a " pa1, . . . , aLq P A L be a temporal sequence of users' activities of length L. We choose the model M0 for observed process, meaning that the emission of a ℓ , at a given step ℓ, does not depend on any previous observation. It only depends on the hidden strategy at the same time step. The emission probability of an observation a P A for a given strategy u P S is given by: Epa, uq " Pr pa|uq .

(

) 2
The matrix E contains the emission probabilities of any activity for any strategy. Assuming that S, A and π are known, the HMM model parameters is fully described by H " tE, Tu, which represents the core information about the HMM behavior. The MMM highly relies on the emission matrix E and the transition matrix T to respectively characterize the users' strategies and the structure of the Map. For these reasons, it is extremely important that these two matrices precisely match the process under study. To do so, the coefficients of the two matrices are learned based on logs produced by the enactment of the process. This paper focuses on unsupervised learning to estimate E and T since it has been proven to be efficient and offers a higher performance than supervised learning of HMM [START_REF] Rabiner | An introduction to hidden markov models[END_REF]. Unsupervised learning estimates these parameters based only on traces of activities (without prior knowledge about the strategies set S). The Baum-Welch Algorithm (BWA) [START_REF] Baum | A maximization technique occurring in the statistical analysis of probabilistic functions of markov chains[END_REF] is most commonly used to learn the parameters of a HMM. The BWA estimates the HMM parameters that locally maximize the probability of having these sequences generated by the HMM. More precisely, the BWA maximizes the likelihood of H:

H ˚" arg max H N ź n"1 Pr pan|Hq , (3)
where N is number of observed sequences in a dataset containing activities a1, . . . , aN .

It is important to highlight the BWA requires the cardinals of N " |S| and M " |A| to run. Regarding the set of activities A can simply be obtained by identifying the different activities in the dataset. However, the information about number of strategies does not exist in the dataset. Therefore, a heuristic method is used in this paper, which consists in generating several HMMs models with different numbers of strategies and observing the associated emission matrices E. It occurs that as the number of possible strategies increases, the number of different strategies obtained in the emission matrices reaches a threshold. It means that when the number of possible strategies is too high, the BWA produces an emission matrix with several identical strategies. Consequently, this observed threshold sets the right number of strategies.

Deep Miner Algorithm

Once model parameters T and E are estimated by the BWA, the problem is how to extract a Map process model which fits actual process model. As a first step into this direction, we propose a metric which has the interesting property of taking into account both fitness and precision to optimize the Map process model, whereas classical metrics in process modeling address either fitness or precision (see [START_REF] Rozinat | Towards an evaluation framework for process mining algorithms[END_REF] for an overview of the existing metrics).

Extracting a Fine-grained Map

We recall that the matrices generated by the BWA are an emission matrix E, giving the probabilities of generating any activity while performing a strategy and a transition matrix T, giving the probabilities of transition between any couple of strategies ps, s 1 q P S 2 .

Clearly, there is a strong link between the transition matrix and the topology of the Map process model we want to extract. To extract a Map from a transition matrix, the two following constraints must be verified: (i) any transition between possible strategies in the transition matrix should be possible on the Map; (ii) any transition between possible strategies in the Map should be possible in the transition matrix.

The first constraint can be seen as a criterion for fitness since it ensures that all the transitions learned from the dataset are present in the Map. The second constraint corresponds to a criterion of precision since it aims at avoiding introducing extra-transitions in the Map that are not learned from the dataset. Our goal is to find the Map that best satisfies both of them. In the next part, we define a metric which is a trade-off between fitness and precision and also captures the relative importance of transitions.

Proposed Metric of Fitness and Precision

The topology of a Map m can be defined by the set of its sections, each comprising a source sub-intention, a strategy and a target sub-intention. We formally write m " pm k q kPt1,...,Ku ,

where k denotes the index of a section and K is the total number of sections of the Map. For each k P t1, . . . , Ku, m k " pi, s, jq P IˆSˆI. The component m k p1q is the source sub-intention of section k, m k p2q is the strategy of section k, and m k p3q is the target sub-intention. On the Map m, a transition from strategy s to strategy s 1 is possible if and only if there exist pk, k 1 q P t1, . . . , Ku 2 such that m k p2q " s, m k 1 p2q " s 1 , and m k p3q " m k 1 p1q. In the following, we use the symbol α to denote if a transition is possible or not in the Map:

α s,s 1 " $ & % 1 if Dpk, k 1 q P t1, . . . , Ku 2 such that m k p2q " s m k 1 p2q " s 1 , and m k p3q " m k 1 p1q, 0 otherwise. ( 5
)
In the transition matrix T, we only consider as valid transitions with a probability above a given threshold ε. The value of ε has to be chosen heuristically, to counter the effects of noise and artifacts in the dataset. We define:

ω s,s 1 " " 1 if Tps, s 1 q ě ε, 0 if Tps, s 1 q ă ε. (6)
Classically, the criteria of fitness and precision between T and m can be expressed by the expressions known as recall and precision. In our context, we define these two expressions as RecpT, mq "

ř s,s 1 ω s,s 1 α s,s 1 ř s,s 1 ω s,s 1 , (7)
PrepT, mq "

ř s,s 1 ω s,s 1 α s,s 1 ř s,s 1 α s,s 1 . ( 8
)
The numerator of both expressions is the number of significant transitions in T that are present on the map m, while the denominators are the number of significant transitions in T and the number of transitions on m, respectively. Since our goal is to find a map that fits best the transition matrix with respect to both recall and precision, we can use the classical F-measure which expression is:

F1pT, mq " 2 PrepT, mqRecpT, mq PrepT, mq `RecpT, mq . (9)

Optimization Problem

Now that the proper metric has been defined, we need to find the Map that maximizes it. The solution of this problem belongs to the set

M " arg max m F1pT, mq. (10)
Since we want to obtain a Map with the simplest structure, we choose the solution with the lowest number of sections.

In other words, the solution is

m ˚" arg mPM min |m|, (11)
where |m| stands for the number of sections in m. However, finding m ˚is a difficult task since m generally belongs to a high-dimension space. Indeed, it can be shown that there are 2 |S| 2 possible Maps for |S| different strategies. Consequently, computing all the possible Maps with a brute force method then comparing their F-measures is not an option. Instead, we developed an algorithm that solves [START_REF]Usage data collector[END_REF] The first part of algorithm 1 associates a target subintention to each strategy of S. In the second part, if a transition probability from strategy s to strategy s 1 is above the threshold ε, a section is added to the Map from the target sub-intention of s to the target sub-intention of s 1 . This section ensures that the transition given by T is also present in the Map. With this algorithm, recall and precision, defined in [START_REF] Cook | Discovering models of software processes from event-based data[END_REF] and [START_REF] Dardenne | Goal-directed requirements acquisition[END_REF], have the advantage of being equal to 1. Indeed, ε defines the accuracy level of the Map. When ε is close to 0, almost all the transitions from the unsupervised model are present in the obtained Map. Consequently, the likelihood of the obtained Map is high but the Map is hardly understandable by humans since it has too many sections. However when ε increases, the number of sections, as well as the likelihood of the obtained Map, decrease. The Map gets more easily understandable by humans but it is not as accurate in terms of transition.

Map Miner Algorithm

Deep Miner algorithm generates the low-level intentions or sub-intentions shown by ta, b, c, ¨¨¨u (figure 3). To extract high-level intentions from low-level intentions, Map Miner algorithm has been developed to automatically perform this task. To do so, Map Miner algorithm uses a clustering algorithm, K-means [START_REF] Hartigan | Algorithm as 136: A k-means clustering algorithm[END_REF] to group the sub-intentions into the intentions. Indeed, this multi-level topology is due to the deep architecture of the brain. The extensive studies on the visual cortex show cognitive processes have a deep structure and humans organize their ideas and concepts hierarchically. First, they learn simpler concepts and then compose them to represent more abstract ones [START_REF] Bengio | Learning deep architectures for ai[END_REF]. Note that the number of intentions is a parameter that has to be chosen. The choice of these parameters allows researchers to obtain Maps with different level of precision. Due to lack of space, this algorithm will be detailed in a future work.

A PROOF OF CONCEPT

To evaluate MMM, we conducted a tailored experiment with the Master students in computer science of Sorbonne University. According to the experiment, 66 students created Entity/Relationship (E/R) diagrams using the prescribed Map process model (figure 2). Indeed, for this particular experiment, the students were asked to follow the prescribed Map while creating their E/R diagrams. Our goal is to compare the actual Map process model discovered by MMM to the prescribed Map. Regarding this prescribed Map, students can select ten strategies to fulfill four intentions, i.e., Start, Specify an entity, Specify an association and Stop. From Start, it is possible to progress in the process by selecting strategies leading to intentions but once the intention of Stop is achieved, the enactment of the process finishes. Table 1 represents the activities and related strategies that the students perform to fulfill the four intentions. The event logs comprising students' activities are recorded by a web-based tool. Once the event logs were available, MMM has been applied on them to trace back this procedure and rebuild the Map process model that was actually followed. Finally, the conformity between the prescribed Map and the discovered Map is checked (see section 3.1). This knowledge can be useful to (i) improve the software used by the students to make the prescribed model easier to follow, (ii) modify the prescribed model by accounting to the process the students actually followed.

Applying MMM on Dataset

Once the students' traces are recorded, MMM is applied to obtain the fine-grained and coarse-grained Map process models. As a first step, the number of strategies must be fixed by the heuristic method described in section 2.2. As a result, we obtain 10 as number of strategies. Then BWA estimates the parameters of the transition matrix and the algorithm described in 2.3.3 is then applied to obtain the structure of a fine-grained Map, i.e., what is the source sub-intention and the target sub-intention of each strategy (the sections). As described earlier, the value of ε has to be set to obtain a trade-off between the accuracy of the Map and its understanding. Figure 3 2 and I 1 3 (large circle on figure 3). The discovered strategies for each high-level intention allow identifying the intentions I 1 2 to Specify an entity and I 1 3 to Specify an association.

' There is a number of matches between the new groups of strategies in the obtained Map and the groups of strategies in the prescribed Map. For instance, S1 and S 1 1 , S2 and S 1 1 , S10 and S 1 10 are made of similar activities. The few mismatches between prescribed and obtained strategies indicate that some prescribed strategies were not followed as intended by the students. This shows how the students preferred to behave. For instance, in the prescribed Map, activity a2 is only present in strategy S2 for intention I2 whereas in the obtained Map, it is present in many strategies: S 1 1 , S 1 6 , S 1 7 , and S 1 9 for intentions I 1 2 , and I 1 3 . The same phenomenon is true for activity a1. It means that these particular activities are used by students during the entire process and not only for a single intention.

It is important to highlight that the likelihood (3) of the HMM model is ´2.36e 3 (logarithmic scale), which is higher than the likelihood of the obtained Map (´2.54e 3 ). This is normal since the Map formalism restricts some transitions (e.g., from the Stop to the Start) that are generated by the HMM model.

CASE STUDY: ECLIPSE UDC

The goal of this case study is to reconstruct the Map process model of developers who committed their code to Eclipse UDC server hosted by Eclipse Foundation [START_REF]Filtered udc data[END_REF]. The Eclipse Foundation provides UDC dataset to help committers and organizations to better understand how the community makes use of Eclipse platform [START_REF]Usage data collector[END_REF]. In this perspective, our contribution is to model the UDC developers' behaviors in terms of intentions and strategies while using Eclipse platform. The obtained Map can help to better understand developers' behaviors.

The dataset contains 1, 048, 576 event logs from developers who agreed to send their data back to the Eclipse Foundation. These data aggregate activities from over 10, 000 Java developers between September 2009 and January 2010. The activities are recorded by timestamps for each developer, which allows knowing when and by whom activities were committed.

Applying MMM on Dataset

In order to apply MMM, it is important to prepare the dataset. The number of unique developers' activities per month exceeds 500 activities. This number contains both the recurring activities and the non-recurring activities, i.e., activities which are not frequently performed by developers. These activities are not representative of the developers' behavior characteristics because they have not been repeated enough to be a behavioral-pattern. For this reason, and also for readability, we limit this study to the 150 most frequent activities performed by developers. Table 2 contains the list of these activities. Some of these activities are the commands performed directly by developers; some of them are the frameworks, plug-ins or built-in features of Eclipse used by developers during their development process. For readability reasons, the prefix org.eclipse of the activities is removed. The plug-ins and frameworks are shown in bold letters and the related activities are inside brackets.

Once the dataset is ready, BWA estimates the transition matrix (developers' strategies). Note that, once again the number of strategies obtained by the heuristic method for this case study is 10. The strategies are represented in table 2 with their corresponding groups of activities. Finally, the Map obtained by Deep Miner and Map Miner algorithms is shown on figure 5.

Figure 4 depicts the effect of the choice of ε on the likelihood and the number of sections of the obtained Map. As mentioned earlier, ε expresses the level of abstraction for a Map. An expert can choose the value of ε regarding the expected level of abstraction. In this case study, the value of ε is set to 0.06 to have a good trade-off between having a likelihood with a relative high value and a reasonable number of sections.

Regarding the obtained Map, 22 sub-intentions are grouped by Map Miner algorithm into 7 groups of high-level intentions. Note that MMM can discover accurately the beginning and the end of a process; thus the intentions Start and Stop are clearly determined on the obtained Map. The transition probabilities from one intention to a strategy are annotated on the arrows. These values correspond to the probabilities that the developers selected a strategy from a given intention. The values on the loops indicate the probabilities that the developers continued to perform the activities related to the looped strategies.

Naming Strategies and Intentions

As found in E/R diagrams experiment and this case study, MMM discovers the strategies (the arrows) and where they lead, i.e., intentions (the nodes). In other words, MMM reconstructs the topology of the Map process model from event logs; the names of strategies and intentions are not fully automatically generated. Nevertheless, it is possible to infer the names of strategies and intentions from the emission matrix E. Indeed, E specifies the activities associated to each strategy discovered by the MMM (see table 2). Therefore, based on the names of activities grouped into a strategy and through a semantic analysis of their properties and interrelationships, it is then possible to manually infer the names of the strategies. In the same way, since the strategies lead to intentions, the names of intentions can be inferred by analyzing the strategies leading to each intention. For instance, the main activities grouped into the strategy S5 are 'refactoring.commands', 'jdt.junit', 'debug.ui.commands', etc. From these activities one can infer the developers wanted to debug, to refactor and to test a code; thus, the name inferred for this strategy is by refactoring, testing and debugging. Further, the main activities for strategy S6 are 'delete', 'paste', 'copy', 'undo', etc. This means the developers wanted to modify a code or a file; the name inferred for this strategy is by file modification. Since both strategies lead to an intention, we infer that the developers who performed S5 and S6 intended to Fix a bug. By applying this procedure, the names of all strategies (denoted on the arrows) and intentions are semi-automatically inferred. The inferred names of intentions are Start, Initiate the development, Manage tasks, Fix a bug, Improve the code, Commit the code. This naming protocol remains to be fully automated by building an sophisticated ontology.

Developers' Behavior Analysis

Discovering the Map for Eclipse UDC developers allows understanding the developers' behaviors during the development process. As shown on figure 5, they have selected different sequences of strategies with different probabilities, to fulfill their intentions. An expert can analyze these behaviors in order to understand how/why developers make use of different components or plug-ins of Eclipse: where they follow the best practice of software development projects and where they deviate from these rules, which components or plug-ins are more involved than the others, which strategies are more/less taken or where are system bottlenecks, etc. The obtained Map can also be used to provide recommendations to developers in order to choose the best path (strategies) to fulfill his/her intentions. In this case study, there is no prior model to compare with the obtained Map. However, MMM has proven to be effective with the controlled experiment (see 3) and the likelihood of the obtained Map is higher than the prescribed one. Hereafter, several observations, from the obtained Map, are detailed to attest the aforementioned claims in practice.

Observation 1.

The developers' activities involve the usage of frameworks and plug-ins such as Mylyn, Equinox, team/CVS, Junit, built-in features of Eclipse such as Eclipse Core, Debug and API such as ltk (Language Toolkit). Figure 6 depicts the usage probabilities of these frameworks in each strategy. We can also observe the usage frequency of each framework/plugin/tools among the strategies. For instance, the usage frequency of Mylyn framework is 4 times among 10 strategies and its usage probabilities for strategy S1 is 1 whereas for strategy S5 it is 0. These values help detecting if any of these frameworks or tools is underused. For instance, we observe that the refactoring tool ltk is underused since it has a low usage probability (see also observation 4). Observation 2. The developers who start a development process choose one of the 4 first strategies, i.e., S1, S2, S7, S9. If they already have an ongoing program at hand, they tend to adopt either the strategy S7: by reviewing and testing to Improve the code or the strategy S9: by CVS committing to Commit the code. On the other side, the developers who start a new development choose either the S2 strategy: by regular programming activities to Initiate the development or choose the strategy S1: by project tracking and team planning to Manage tasks with probability 0.39 and 0.12 respectively. This observation suggests that the developers of this case study tend to start programming by building first the baselines for software architecture through dividing the programs into different modules/packages using OSGI-based design.

After decomposing the software into sub-modules, the developers utilize the strategy S3 : by code/task sharing which involves mainly Mylyn framework (described in scenario 3) which can be integrated with the Bugzilla bugtracker system and issue system. Therefore, tasks and the content of these tasks can be shared among developers. The high transition probability of this strategy means the developers tend to share code/task in order to fulfill Manage tasks. Observation 3. The developers who have the intention to Manage tasks choose the strategies S1 and S3. Regarding Table 2, the activities related to these strategies involve Mylyn framework which is the task and application lifecycle management (ALM) framework for Eclipse. It helps the developers to work efficiently with many different tasks such as bugs, problem reports or new features. It monitors users' activities and preserve the context of the task-at-hand to focus the Eclipse UI on the related information. For instance, while working on a current task, if the developers have to work on another task, e.g., an occurred bug, Mylyn preserves the context of the current task. Thus, the developers can work on another task without losing the context of previous task. This procedure is discovered in the obtained Map of Eclipse. The activities of the developers while they Manage tasks are interrupted (e.g., for an urgent bug) and they choose the strategy S5 to Fix a bug. To switch to the previous task, they first commit and report the bug then they continue managing tasks. We can deduce the Mylyn framework has reliable and relevant functionalities for developers and it is not underused since they work with it 47% (transition probability of 0.47) of their time and they use it frequently (Figure 6). Observation 4. When the activities of the developers during Manage tasks are interrupted, they choose strategy S5 to Fix a bug. The procedure of fixing a bug may involve refactoring existing code, writing unit tests, editing and modifying involved code and finally fixing the affected code. The strategy S5 : by refactoring, testing and debugging represents this procedure. This strategy is defined as a best practice to fix a bug, which means the developers who adopt this strategy respect the guidelines of software development. However, they perform this strategy with probability 0.22 whereas they prefer to Fix a bug by file modification with a higher transition probability (0.33). Moreover, Figure 6 shows a low usage frequency and usage probability for ltk (Language Toolkit) which is an API for automated refactoring in Eclipse-based IDEs. This means the developer prefer refactoring manually instead of using the refactoring and debugging tools of Eclipse provided for this purpose. This confirms some results of empirical research [START_REF] Murphy-Hill | Breaking the barriers to successful refactoring[END_REF][START_REF] Vakilian | Use, disuse, and misuse of automated refactorings[END_REF][START_REF] Fowler | Refactoring: improving the design of existing code[END_REF][START_REF] Xing | Refactoring practice: How it is and how it should be supported-an eclipse case study[END_REF] that refactoring tools are seldom used and that they are not developers-friendly enough.

Observation 5. Bug fixing includes debugging and refactoring of different software modules. Once developers have fixed a set of bugs, they choose either strategy S8: by patch applying with probability 0.05 or strategy S7: by reviewing and testing with probability 0.07 to fulfill the intention of Improve the code. This observation means when debugging and refactoring have an impact on different parts of the program, the developers improve their code by patch applying. If debugging and refactoring change the program locally, they manually changes the code and send it for reviewing and testing. The probabilities describe that the developers tend to modify the codes manually. Observation 6. The Map can be used as a behavioral pattern to build recommender system for assisting developers in their daily development tasks. For example, this recommender system can suggest developers to avoid some problematic paths/strategies which might deviate from organizational best practices and to take some more effective paths/strategies. For instance, since the procedure of refactoring and debugging might affect the code in different parts of the program, it is recommended to check the coherence integrity of the program. To do so, after fixing a bug, the developers can be recommended to take the strategy S4: by OSGI-based design to Initiate the development, to check if the refactoring and debugging have been impacted the OSGI-based design (e.g., if the dependencies between the modules are changed, etc).

Process Improvement

The obtained Map also helps improving the software usability in different areas [START_REF] Bass | Software architecture in practice, 2nd edn. sei series in software engineering[END_REF]. The Map can help the novice or unfamiliar users learning system features by making the task of learning easier, by using the Map obtained from previous development process as a guideline. For instance, when their intentions are known, they can be recommended which strategies and activities might be useful to fulfill their intentions. Since the intentional topology of a Map makes it userfriendly, it can help software designer designing systems that enable users to be more efficient in their operations. This can be done by adapting the system to the users' needs or by assisting users step by step while the enactment of a process. Using a Map increases also the users' confidence and satisfaction in the enactment of a process. All these points contribute to improving the usability of the software products.

RELATED WORK

The workflow models approaches propose to discover process models from event logs generated during process enactment. However, they model users' behaviors in terms of activities [START_REF] Van Der Aalst | Workflow mining: Discovering process models from event logs[END_REF][START_REF] Van Der Aalst | Process mining: discovery, conformance and enhancement of business processes[END_REF][START_REF] Cook | Discovering models of software processes from event-based data[END_REF][START_REF] Lorenzoli | Automatic generation of software behavioral models[END_REF] and overlook the underlying users' intentions and strategies. Intention Mining is a new field of research that does not exceed a few works [START_REF] Park | Extracting search intentions from web search logs[END_REF][START_REF] Baeza-Yates | The intention behind web queries[END_REF]. These works differ from our approach because they look for a single user's intention underlying a single event log while our approach proposes to infer common users' intentions during enactment of a process to achieve the ultimate process goal. HMMs are commonly applied in many fields such as speech recognition [START_REF] Juang | Hidden markov models for speech recognition[END_REF] and bioinformatics [START_REF] Enright | An efficient algorithm for large-scale detection of protein families[END_REF]. HMMs are used for model discovery by Cook et al. [START_REF] Cook | Discovering models of software processes from event-based data[END_REF][START_REF] Herbst | Integrating machine learning and workflow management to support acquisition and adaptation of workflow models[END_REF]. This work concludes that the Ktail and Markov methods are more promising than RNet method to be used in practical applications. However, these works do not address the intentional dimension of processes that cause the activities performance. Application of HMMs in Intention Mining has been proposed and applied for the first time in our previous works [START_REF] Khodabandelou | Contextual recommendations using intention mining on process traces[END_REF][START_REF] Khodabandelou | Process mining versus intention mining[END_REF][START_REF] Khodabandelou | Supervised intentional process models discovery using hidden markov models[END_REF].

Finite State Machine (FSM) is used in some works to model users' behaviors [START_REF] Biermann | On the synthesis of finite-state machines from samples of their behavior[END_REF][START_REF] Lorenzoli | Automatic generation of software behavioral models[END_REF]. While our approach models hidden states as users' strategies, FSM is a simple automaton and is not appropriate to model cognitive processes.

Several experimental works address the developers' behavior in the software engineering field [START_REF] Murphy-Hill | Breaking the barriers to successful refactoring[END_REF][START_REF] Vakilian | Use, disuse, and misuse of automated refactorings[END_REF][START_REF] Lorenzoli | Automatic generation of software behavioral models[END_REF]. In [START_REF] Murphy-Hill | Breaking the barriers to successful refactoring[END_REF], improvements for the user interface of automated refactoring are proposed by instructing several participants to apply the Extract Method refactoring on several open source projects. In [START_REF] Vakilian | Use, disuse, and misuse of automated refactorings[END_REF], the focus is on Eclipse UDC refactoring histories to understand why developers underuse automated refactoring. However, these approaches are based on statistical reports and do not consider underlying users' intentions during the development.

THREATS TO VALIDITY

There are four main issues that threat the validity of the proposed approach. First, the mined Map may suffer from underfitting problems if the number of activities sequences used to estimate the parameters of the HMM is not high enough. Indeed, these sequences have to capture all the possible behaviors while enacting the process under study to produce an accurate Map. Second, the BWA requires an important number of iterations to converge to a result. For instance, it converges at 9, 986 learning iterations for the E/R diagrams experiment and 20, 237 learning iterations for the Eclipse case study. Moreover, it cannot always be guaranteed to converge to the global maximum likelihood. Third, although the MMM automatically discovers the topology of the Map process model, the names of strategies and intentions are still inferred semi-automatically. The manual part of this naming procedure introduces a human bias. Fourth, the M1M0 topology chosen for the HMM is the most sophisticated topology allowing the use of an algorithm such as BWA or equivalent algorithms. More complex topologies may actually be more appropriate to model some processes. However, there is no known algorithm to estimate the parameters of these topologies, as BWA does for M1M0. For this reason, the scope of MMM is limited to the M1M0 topology.

CONCLUSIONS

This paper has presented the Map Miner Method (MMM), a method for automating the construction of an intentional process model from users' activities logs. Constructing an intentional process model from event logs is a novel approach to model processes. It helps understand the users' intentions and strategies while using software products. Further, it can help software designers adapting the products functionalities to better meet users' needs, therefore making products more user-friendly. On the other hand, the intentional model can assist any user (novice or experimented) by providing recommendations to choose the next step of a process.

The main contribution of this work is to build from theory a method which fully constructs the topology of an intentional model, only based on users' activity logs. This makes the method easily applicable to any dataset, as long as it is made of users' traces of activities. In this paper, MMM was validated by a controlled experiment (creation of E/R diagrams by students) and then by a large-scale case study (developers of Eclipse UDC).

Although the MMM automatically discovers the topology of the intentional model, the names of strategies and intentions are still inferred semi-automatically. This could be fully automated by building a more sophisticated ontology. In addition, we are developing an ProM [24] plug-in which will allow modeling processes in intentional manner.

Figure 1 :

 1 Figure 1: An overview of the Map Miner Method

Figure 2 :

 2 Figure 2: Map process model for the construction of E/R diagrams.

  depicts the fine-grained Map (small nodes) for ε " 0.07 and coarse-grained Map (large nodes) obtained by Deep miner and Map Miner algorithms, respectively. What we learn from the obtained Map is: ' Deep Miner algorithm found 9 sub-intentions as well as intentions Start and Stop. Map Miner algorithm groups the sub-intentions into the high-level intentions to obtain coarse-grained Map. The high-level intention are shown by I 1

Figure 3 :

 3 Figure 3: Map obtained by MMM for E/R diagrams experiment.

Figure 4 :

 4 Figure 4: The effect of the choice of ε on the likelihood and the number of sections of the obtained Map for the Eclipse traces.

Figure 5 :

 5 Figure 5: The obtained Map for Eclipse UDC.

Figure 6 :

 6 Figure 6: Usage probabilities of different Eclipse elements for each discovered strategy.

  S do associate to s a target sub-intention is; end for each strategy s P S do for each strategy s 1 P S, s 1 ‰ s do if Tps, s 1 q ě ε then create a section from is to i s 1 with strategy How to obtain a Map from S, T, and ε.

	with a
	complexity bounded by |S| ˚p|S| ´1q. This algorithm is
	detailed below.
	s 1 ;
	end
	end
	end
	Algorithm 1:

Data: strategy set S, transition matrix T, threshold ε Result: map m for each strategy s P

Table 1 :

 1 Strategies and related activities

	Labels	Name of	Related activities
		strategies	(activities labels)
	S1	By completeness	Create entity (a1)
		(model)
	S2	By completeness	Link attribute to entity (a2)
		(entity)
	S3	By normaliza-	Delete Link attribute to entity (a6),
		tion		Delete entity (a5), Define primary
				key (a7)
	S4	By generaliza-	Create entity (a1), Create generaliza-
		tion		tion link (a3)
	S5	By	specializa-	Create entity (a1), Create specializa-
		tion		tion link (a4)
	S6	By reference	{Delete link attribute to entity, Cre-
				ate entity, Create association, Link
				association to entity} (a8), {Create
				association, Link association to en-
				tity} (a9)
	S7	By decomposi-	{Create association, Link association
		tion		to entity} (a9)
	S8	By normaliza-	{Delete association, Delete Link
		tion		attribute to association}(a10)
	S9	By completeness	Link attribute to association (a11)
		(assoc.)
	S10	By completeness	Check the model (a12)
		(final)

Table 2 :

 2 Strategies labels and related activities for Eclipse UDC Strategies labels Activities names S1 mylyn.tasks.ui.commands.gotoTest, junitShortcut.debug], ltk.ui.refactoring.commands.[deleteResources, renameresources, moveResources], compare.selectPreviousChange S6 ui.edit.[delete, paste, copy, undo, text.goto.lineEnd, text.contentAssist.proposals, text.goto.wordNext], ui.file.save S7 cdt.ui.editor, jdt.junit.[junitShortcut.rerunLast, gotoTest, junitShortcut.debug], team.cvs.ui.[CompareWithRevision, CompareWithLatestRevisionCommand, CompareWithWorkingCopyCommand],ui.edit.[delete, paste, copy undo, text.goto.lineEnd, text.contentAssist.proposals, text.goto.wordNext]

	S8	team.ui.[synchronizeLast, teamSynchronizingPerspective, synchronizeAll, applyPatch],
		ltk.core.refactoring.refactor.[create.refactoring.script, show.refactoring.history]
	S9	mylyn.monitor.ui, mylyn.context.ui, mylyn.commons.ui, team.cvs.ui.[commitAll,
		Commit, CompareWithRemote, Sync]
	S10	mylyn.monitor.ui, mylyn.bugzilla.core, mylyn.bugzilla.ui, team.cvs.ui.[commitAll,
		Commit, CompareWithRemote, Sync]

[OpenTask, AddTaskRepository, ActivateTask, SearchForTask], mylyn.context.ui.commands.[Open.context.dialog, AttachContext, interest.Increment, interest.Decrement], mylyn.monitor.ui, mylyn.team.ui S2 core.[jobs, net, filesystem, resource, runtime, variables, contenttype, databinding.observable], equinox.p2.ui.sdk.install S3 mylyn.context.ui.commands.[Open.context.dialog, AttachContext, interest.Increment, interest.Decrement],team.cvs.ui.[branch, replace, GenerateDiff, ShowHistory, Add, Tag,merg, compareWithTag], jsch.core, mylyn.[monitor.ui, team.ui, commons.ui, bugzilla.ui] S4 pde.ui.EquinoxLaunchShortcut.run, equinox.p2.ui.sdk.update, equinox.[ds, simpleconfigurator.manipulator, frameworkadmin, app, common, directorywatcher, engine, core, metadata.repository, garbagecollector, ui.sdk.scheduler, repository, preferences, exemplarysetup, registry, updatechecker] S5 core.[databinding.observable, core.net, core.filesystem, core.resource, core.runtime, core.variables, core.contenttype], debug.ui.commands.[RunLast, Debuglast, eof, StepOver, TerminateAndRelaunch, execute, AddBreakPoint, TogglebreakPoint], jdt.debug.ui. [commands.Execute, commands.Inspect], jdt.junit.[junitShortcut.rerunLast,


Sébastien Varrier
email: sebastien.varrier@gipsa-lab.grenoble-inp.fr

Damien Koenig
email: damien.koenig@gipsa-lab.grenoble-inp.fr

John J Martinez
email: john.martinez@gipsa-lab.fr

Robust fault detection for Uncertain Unknown Inputs LPV system ✩

Keywords: Robust Fault detection (FD), Linear Parameter Varying (LPV), Uncertain Unknown Inputs system

This paper focuses on robust fault residual generation for Uncertain Unknown Inputs Linear Parameter Varying (U -LPV) systems. Firstly, the problem is addressed for standard LPV systems based on the adaptation of parity-space approach. The main objective of this approach is to design a scheduled parity matrix according to the scheduling parameters. It results a perfectly decoupled parity matrix face to the system states. Then, the major contribution of this paper relies in the extension to U -LPV systems. Since most of models which represent practical/real systems are subject to parameters variation, unmodeled dynamics and unknown inputs, the approach is clearly justified. The residual synthesis is rewritten in terms of a new optimization problem and solved using Linear Matrix Inequalities (LMIs) techniques. An applicative illustration is proposed and rests on a vehicle lateral dynamics system.

Introduction

The issue of Fault Detection (FD) in dynamic systems has received considerable attention in both research and application domains since the last two decades. Among all concrete systems, cars represent a wide field of interest in terms of diagnosis. In effect, it has been noticed the emergence of new safety systems for vehicles such as anti-lock braking (ABS), adaptive cruise control (ACC), electronic stability control (ESC) which are incontrovertible products on modern cars. Those electronic/mechanical systems which are designed to enhance the security in vehicles might lead to extremely dangerous situations in case of failures.

Facing this reality, researchers and engineers are working on solutions to strengthen the reliability by adding supplementary fault detection layers on their equipments. However, most of modern process are complexe systems and the synthesis of such fault detection procedure is extremely difficult to perform. In this field, many model-based fault detection and isolation (FDI) procedures has been carried out by researchers. It can be cited, for instance, analytical redundancy-based methods as proposed in [START_REF] Chow | Analytical redundancy and the design of robust failure detection systems[END_REF] and well recalled in [START_REF] Gertler | Fault detection and diagnosis in engineering systems[END_REF], some statistical and geometrical methods in [START_REF] Basseville | Detection of Abrupt Changes -Theory and Application[END_REF][START_REF] Fang | A double-threshold-testing robust method for fault detection and isolation in dynamic systems[END_REF][START_REF] Cao | Fault diagnosis in a class of nonlinear systems using identification and glr testing[END_REF][START_REF] Balas | Invariant subspace for lpv systems and their applications[END_REF], and some observer-based approaches as in [START_REF] Ding | Model-based Fault Diagnosis Techniques[END_REF][START_REF] Chen | Robust Model-Based Fault Diagnosis for Dynamic Systems[END_REF][START_REF] Simani | Model-based Fault Diagnosis in Dynamic Systems Using Identification Techniques[END_REF]. More recently, researchers focused on optimization-based techniques for fault detection (e.g. H ∞ -based approaches) as proposed in [START_REF] Xinzhi | On designing H ∞ fault estimator for switched nonlinear systems of neutral type[END_REF][START_REF] Yueyang | Parity space-based fault detection for linear time-varying systems with multiple packet dropouts[END_REF][START_REF] Maiying | Parity spacebased fault estimation for linear discrete time-varying systems[END_REF] and references therein.

Within the same creative impulse than [START_REF] Apkarian | Self-scheduled H ∞ control of linear parameter-varying systems : A design example[END_REF], many works has been carried out about Linear Parameter Varying (LPV) systems. Such models have received many attention as long as they can be used to represent nonlinear systems. Moreover, vehicle systems which are strongly nonlinear systems are often modeled as LPV systems. This motivates some researchers from the FD community to develop model-based methods using LPV models [START_REF] Balas | Failure detection for lpv systemsa geometric approach[END_REF][START_REF] Balas | Invariant subspace for lpv systems and their applications[END_REF][START_REF] Bokor | Linear parameter varying systems : a geometric theory and applications[END_REF][START_REF] Wang | Robust fault detection for a class of discrete-time lpv systems with time-delays[END_REF][START_REF] Kwiatkowski | Less conservative polytopic lpv models for charge control by combining parameter set mapping and set intersection[END_REF]. There are two commonly used approaches. First the fault estimation methods where the estimated fault is used as the fault indicating signal. Secondly, residual generation methods where the residuals are synthesized in order to be robust against modeling errors and unknown inputs.

In this paper, the contribution relies in the design of fault indicators for a general class of Uncertain, Unknown Inputs non-linear system which can be written as LPV Uncertain systems subject to Unknown Inputs, namely U -LPV systems for simplicity. The approach is based on the synthesis of a residual which provides the information on the faultiness of the system. First, the objectives are expressed for LPV systems. Here, the proposed approach is similar to that presented by the authors in [START_REF] Varrier | A parity space-based fault detection on lpv systems : Approach for vehicle lateral dynamics control system[END_REF], but extended from LTI parity-space approach. In this case, the parity matrix is computed depending of the scheduling parameters of the system, to guarantee a perfect decoupling face to system dynamics. The parity-matrix evaluation involves symbolic computation and matrix inversions.

Furthermore, the major contribution concerns the robustness against uncertainties and parameter variation. The synthesis of the parity matrix is handled by expressing the objectives as an optimization problem. The aim is classical : minimize the residual sensitivity with respect to uncertainties and disturbances and maximize its sensitivity face to faults. The approach of the generalized eigenvalues/eigenvectors -as a generalization of the approach expressed in [START_REF] Ding | Model-based Fault Diagnosis Techniques[END_REF] -is very hard to implement in this application. Its computation involving symbolic computation is not applicable in this case. Facing this difficulty, the optimization problem is finally rewritten in terms of an LMI optimization problem.

The paper is organized as follows : Section 2 presents the modeling of uncertain LPV systems subject to unknown inputs. Then, Section 3 presents the parity-space based fault detection approach expressed for LPV system. Thus, the main contribution is exposed in Section 4 where the approach is extended to uncertain LPV systems. Finally, an applicative example based on a vehicle lateral dynamic system is handled in Section 5 where the aim is to detect a fault (generally sensor bias) on a lateral acceleration sensor. The performances and improvements of the proposed approach are discussed in the last section.

Uncertain LPV modeling

This section settles the system under consideration used for residual synthesis. The system is an Uncertain Unknown Inputs LPV (U -LPV) system. The difference between the scheduling parameters for LPV definition and uncertain parameters is very important and is highlighted in the next subsections.

System definition

Consider the U -LPV system Σ ∆ defined by :

Σ ∆ : x k+1 = A(ρ k )x k + B(ρ k )u k + B d (ρ k )d k + B f (ρ k )f k y k = C(ρ k )x k + D(ρ k )u k + D d (ρ k )d k + D f (ρ k )f k (1)
where x ∈ R n denotes the state vector of the system, y ∈ R m the output vector, u ∈ R l the input vector, d ∈ R l d some unknown inputs and f ∈ R l f some faults affecting both the state and output vectors of the system. In this representation, matrices X stand for uncertain matrices, presented in the following section.

The vector ρ k = ρ 1k ρ 2k • • • ρ M k defines the vector of the scheduling parameters ρ ik , which are known at each sample time.

Uncertainties modeling

Uncertain matrices are considered in the following additive form :

X(ρ k ) = X 0 (ρ k ) + N i=1 X i (ρ k )δ ik (2)
where X i (ρ k ) are known LPV matrices and δ i are unknown scalars.

Remark 1. In the case of many uncertainties δ i , the matrix X will be very large, roughly full of zeros. Therefore, a change of basis inspired from a singular value decomposition in matrix X should reduce the complexity of the presented methodology as proposed in [START_REF] Koenig | Design of proportional-integral observer for unknown input descriptor systems[END_REF].

Scheduling parameters

In the modeling of the system (equation ( 1)), matrices might depend of the vector

ρ k = ρ 1k ρ 2k • • • ρ M k .
The structure of such matrices is considered as an Affine-LPV form such as :

Z(ρ k ) = Z 0 + ρ 1k Z 1 + • • • + ρ M k Z M (3)
In this modeling, each scalar ρ i is an unknown scalar. However, the main difference between δ i and ρ i relies in the fact that scheduling parameters ρ i can be measured at each sample time while δ i remain unknown.

Faults and unknown inputs

In the modeling presented in [START_REF] Ackermann | Yaw disturbance attenuation by robust decoupling of car steering[END_REF], it has been differentiated unknown inputs d k from faults f k . This distinction is particularly relevant since the residual has only to inform on the faultiness of the system. In this case, unknown inputs will not affect the residual status.

On the other hand, it is sometimes required (for fault isolation) that the fault detector should only be sensitive to a certain class of faults f 1k ⊂ f k and insensitive to another class f 2k ⊂ f k . This requirement can easily be handled be splitting both matrices B f and D f in (1) with respect to f 1k and f 2k as :

B f f k = B f 1 B f 2 f 1k f 2k (4)
and creating the new matrices B * f = B f 2 and B * d = B d B f 1 (idem for matrices D f and D d ). Subscripts * stand for the newly defined matrix.

Finally, the residual will be sensitive to faults f 1k and insensitive to the others f 2k .

Observability assumption

In the sequel, it is assumed that the pair A(ρ k ), C(ρ k ) is always observable for any combination of δ and ρ. As a consequence, the nominal pair

(A 0 (ρ k ), C 0 (ρ k )) is still observable (case δ = O N ×1 ).

U -LPV system

Finally, the U -LPV system given in (1) can be rewritten in the following form :

Σ ∆ :                x k+1 = A 0 (ρ k )x k + N i=1 A i (ρ k )δ ik x k +B(ρ k )u k + B d (ρ k )d k + B f (ρ k )f k y k = C 0 (ρ k )x k + N i=1 C i (ρ k )δ ik x k +D(ρ k )u k + D d (ρ k )d k + D f (ρ k )f k (5)
where it is separated the completely known part of the system from the uncertain one.

For the sake of residual generation for system Σ ∆ , it has been considered to decompose the further study in 2 cases :

• Case of LPV system : A solution for residual generation for LPV systems is firstly proposed. The involved methodology is inspired from the classical parity-space approach. The scheduling parameters are taken into account to generate a scheduled residual.

• Extension to U -LPV systems : Then, the previously exposed methodology is used to tackle the scheduling parameters. An LMI formulation is finally proposed to handle uncertainties and unknown inputs within residual generation.

Both approaches are finally compared in a practical situation in the last section 5.

Fault detection for LPV systems

In this section, it is proposed to design a fault indicator for LPV systems. The fault detection principle is based on the parity space methodology, inspired from the LTI approach (see [START_REF] Chow | Analytical redundancy and the design of robust failure detection systems[END_REF][START_REF] Gertler | Fault detection and diagnosis in engineering systems[END_REF]), but adapted for LPV ones.

The depicted methodology is necessary for the establishment of the final residual for U -LPV systems presented in section 4. Comparison between both approaches is presented in the applicative section 5.

Principle of the approach

In this section, only the following LPV system Σ LP V , without uncertainties nor unknown inputs is considered :

Σ LP V : x k+1 = A(ρ k )x k + B(ρ k )u k y k = C(ρ k )x k + D(ρ k )u k (6)
where x ∈ R n represents the state of the system, u ∈ R l the controlled input, y ∈ R m its output and ρ k the scheduling parameters.

Diagnosis based on the parity-space approach is generated via linear combinations of measurements (sensors) and applied inputs (actuators) taken over a finite window. By making use of known data, it is generated analytical relationships that hold in absence of failures. A fault is so detected when equations are no longer verified.

The key of the approach is to express the output and its time shifted over a horizon s as :

     y(k) y(k + 1)
. . .

y(k + s)      Ys =        C(ρ k ) C(ρ k+1 )A(ρ k ) . . . C(ρ k+s ) s-1 i=1 A(ρ k+s-i-1 )        Hos(ρ k ) x(k) + H us (ρ k )      u(k) u(k + 1) . . . u(k + s)      Us (7)
with

H us (ρ k ) =          D(ρ k ) 0 • • • C(ρ k+1 )B(ρ k ) • • • C(ρ k+2 )A(ρ k+1 )B(ρ k ) C(ρ k+1 )B(ρ k ) • • • . . . . . . • • • C(ρ k+s ) s-1 i=1 A(ρ k+s-i )B(ρ k ) C(ρ k+s-1 ) s-1 i=2 A(ρ k+s-i )B(ρ k ) • • • • • • • • • 0 0 • • • 0 D(ρ k ) . . . . . . . . . . . . 0 • • • C(ρ k+1 )B(ρ k ) D(ρ k )         (8)
In equation [START_REF] Cao | Fault diagnosis in a class of nonlinear systems using identification and glr testing[END_REF], Y s is built from sensor measurements and U s results of the applied inputs. Those data are perfectly known. However, the state x(k) is -a priori -unknown.

The parity-space methodology manages to make the term H os (ρ k )x(k) vanish. Left multiplying equation ( 7) by the so called parity matrix W (ρ k ), the residual r(k) is finally given by :

r(k) = W (ρ k ) T (Y s -H us (ρ k )U s ) (9)
where the parity matrix W (ρ k ) is selected from the parity space P defined by

P {W (ρ k ) s.t. W (ρ k ) T H os (ρ k ) = 0}
Thus in absence of failures, the residual is null. Moreover, for fault isolation, the usual DOS (dedicated observer scheme) or GOS (generalized observer scheme) schemes [START_REF] Frank | Fault diagnosis in dynamic systems using analytical and knowledge-based redundancy : a survey and some new results[END_REF] can be applied.

Parity matrix synthesis

Now, the main objective consists in finding the parity matrix W (ρ k ) which has to be orthogonal to the matrix

H os (ρ k ), i.e. W (ρ k ) • H os (ρ k ) = 0.
First, the matrix H os (ρ k ) can always be split into two sub-matrices as follows :

H os (ρ k ) = H os1 (ρ k ) H os2 (ρ k ) ( 10
)
where the matrix H os1 (ρ k ) is regular and so invertible.

Remark 2. By assumption, the system (6) is observable and so the observability matrix O(A(ρ k ), C(ρ k )) is full rank. As a consequence, for a horizon s chosen s ≥ E( n m ) (where E(•) represents the superior integer part), it is always possible to choose the matrix H os1 (ρ k ) as the regular part of the observability matrix of the nominal system, i.e.

H os1 (ρ k ) = reg O(A(ρ k ), C(ρ k )) .
So for a SISO system, s 1 can be chosen as s 1 = n.

Thus, by defining

W (ρ k ) T = W 1 (ρ k ) T W 2 (ρ k ) T T , the null equality W (ρ k ) T • H os (ρ k ) = 0 can be expressed as : W (ρ k ) T H os (ρ k ) = 0 ⇔ W 1 (ρ k ) T W 2 (ρ k ) T H os1 (ρ k ) H os2 (ρ k ) = 0 ⇔ W 1 (ρ k ) T = -W 2 (ρ k ) T H os2 (ρ k )H os1 (ρ k ) -1 (11)
Finally, the matrix W (ρ k ) T can be rewritten as :

W (ρ k ) T = W 1 (ρ k ) T W 2 (ρ k ) T T = -W 2 (ρ k ) T H os2 (ρ k )H os1 (ρ k ) -1 W 2 (ρ k ) T = W 2 (ρ k ) T -H os2 (ρ k )H os1 (ρ k ) -1 I q P (ρ k ) W (ρ k ) T = W 2 (ρ k ) T P (ρ k ) (12)
According to those algebraic manipulations, the parity matrix W (ρ k ) is built from the knowledge of matrices A(ρ k ) and C(ρ k ). The left hand side matrix W 2 (ρ k ) stands as an extra degree of freedom. It can be chosen unitary for the purpose of this section.

Nevertheless, the matrix W 2 can be used in order to increase the robustness of the system face to uncertainties, as used in the next section.

Choice of the horizon s

According to the depicted methodology, the horizon s in [START_REF] Cao | Fault diagnosis in a class of nonlinear systems using identification and glr testing[END_REF] affects the definition of the residual r(k). Indeed, thanks to equation ( 10) and remark 2, the horizon has to be chosen at least larger than the size of the observability matrix O(A(ρ k ), C(ρ k )). The leading H os1 (ρ k ) matrix will be invertible. Moreover, the matrix H os2 (ρ k ) defines supplementary rows in the H os matrix. Those redundant rows are constructing new residuals in the vector r(k).

To sum up, it is required that the horizon s guarantees the definition of the observability matrix, so using the definition in equation ( 6), s ≥ n m , plus the number of desired residuals. For the sake of this section, where one residual is required, the horizon can be chosen as recalled in [START_REF] Varrier | A parity space-based fault detection on lpv systems : Approach for vehicle lateral dynamics control system[END_REF]:

s = E n m (13)
where E(•) represents the superior integer part.

To conclude, the choice of the horizon for residual generation has to be done respecting equation ( 13), but might be increased to enhance redundant information within the residual.

On the other hand, the residual synthesis involves inversion of a symbolic matrix H os1 (ρ k ) according to the scheduling parameters ρ k see equations ( 9) and ( 12). This symbolic inversion is not restrictive as it can easily be handled via symbolic software.

Fault detection for U -LPV systems

Since a fault detection procedure has been proposed for LPV system, it is now extended to U -LPV ones. Direct extension from the previous approach eliminating all the terms subject to uncertainties and unknown inputs is not available. The further subsection justifies this statement. So, an optimization procedure based on an LMI formulation of the problem is proposed. The aim is to synthesize a residual mainly sensitive to the faults while being non-receptive to uncertainties nor unknown inputs whatever the scheduling parameters are.

Extension of the LPV approach

Now, the system under consideration is the U -LPV system [START_REF] Basseville | Detection of Abrupt Changes -Theory and Application[END_REF]. Similarly than section 3.1, expressing the output y k along the horizon s yields :

Y s (k) -H us U s (k) = H os x(k) + i ζ k (i) H os,i x(k) + i ζ k (i) H us,i U s (k) + H ds U ds (k) + i ζ k (i) H ds,i U s (k) + H f s F s (k) (14)
where ζ k is constructed with δ k , the powers of its elements and multiple inner products in the form :

ζT k = δ 1k • • • δ N k δ 2 1k δ 1k δ 2k • • • δ 1k p δ 1k p-1 δ 2k • • • δ N k s+1 T
where

δ ik q = δ ik δ ik • • • δ ik q products
. The (trivial) classical parity space approach would consist in finding a scheduled parity matrix W (ρ k ) ensuring W (ρ k ) T H os (ρ k ) = 0. It leads to a residual sensitive to the unknown inputs d k , the uncertainties δ ik and to the faults f k . This conspicuous solution is not acceptable for our problem.

Otherwise, it may sometimes be found a parity matrix W (ρ k ) satisfying

W (ρ k ) T H os (ρ k ) H os (ρ k ) H us (ρ k ) H ds (ρ k ) H ds (ρ k ) = 0 ( 15
)
where

H os (ρ k ) = H os,1 (ρ k ) • • • H os,z (ρ k ) .
First, note that the existence of such a matrix is not guaranteed since the rowrank of the matrix H os (ρ k ) H os (ρ k ) H us (ρ k ) H ds (ρ k ) H ds (ρ k ) is not necessarily degenerated. Nevertheless, in the case of existence, the horizon should be high, leading to hard computations and a long fault detection time, as the residual will be sensitive to faults during all the horizon s.

As a consequence, the perfect decoupling is not suitable for on-line computation. A non-perfect parity matrix W (ρ k ) will be sought via an optimization procedure, as introduced in the problem formulation [START_REF] Mammar | Vehicle handling improvement by active steering[END_REF].

Optimization procedure

The aim of the problem is to find a residual r(k) only designed from known data as :

r(k) = W (ρ k ) T (Y s (k) -H us (ρ k )U s (k)) (16)
which has to be sensitive to faults f k and insensitive to uncertainties δ i and to unknown input d k . Those objectives can be expressed in the following optimization problem in the variable W (ρ k ) :

find W (ρ k ) s.t. :

                           W (ρ k ) T H os = 0 max W W (ρ k ) T H f s (ρ k ) 2 min W W (ρ k ) T H os (ρ k ) 2 min W W (ρ k ) T H us (ρ k ) 2 min W W (ρ k ) T H ds (ρ k ) 2 min W W (ρ k ) T H ds (ρ k ) 2 (17)
This problem [START_REF] Mammar | Vehicle handling improvement by active steering[END_REF] can be written as a constrained optimization problem [START_REF] Ding | Model-based Fault Diagnosis Techniques[END_REF][START_REF] Varrier | A parity space-based fault detection on lpv systems : Approach for vehicle lateral dynamics control system[END_REF], as follows:

P 1 :      W (ρ k ) T H os = 0 min W W (ρ k ) T G(ρ k ) 2 W (ρ k ) T H f s (ρ k ) 2 (18)
where

G(ρ k ) = H os (ρ k ) H us (ρ k ) H ds (ρ k ) H ds (ρ k ) .
Following the methodology proposed in section 3.2, this constrained optimization problem can be turned into a classical unconstrained one.

The constraint W (ρ k ) T H os = 0 is guaranteed by considering W (ρ k ) as in [START_REF] Frank | Fault diagnosis in dynamic systems using analytical and knowledge-based redundancy : a survey and some new results[END_REF]. Therefore, the optimization problem [START_REF] Tóth | Discretisation of linear parameter-varying state-space representations[END_REF] becomes an unconstrained optimization problem in the variable W 2 (ρ k ) as :

P 1 : min W 2 W 2 (ρ k ) T P (ρ k )G(ρ k ) 2 W 2 (ρ k ) T P (ρ k )H f s (ρ k ) 2 (19)
which is equivalent to :

P 1 : min W 2 W 2 (ρ k ) T Γ 1 (ρ k ) P (ρ k )G(ρ k )G(ρ k ) T P (ρ k ) T W 2 (ρ k ) W 2 (ρ k ) T P (ρ k )H f s (ρ k )H f s (ρ k ) T P (ρ k ) T Γ 2 (ρ k ) W 2 (ρ k ) = min W 2 W 2 (ρ k ) T Γ 1 (ρ k )W 2 (ρ k ) W 2 (ρ k ) T Γ 2 (ρ k )W 2 (ρ k ) (20)
where Γ 1 (ρ k ) and Γ 2 (ρ k ) are symmetric matrices. Now, problem P 1 stands as an unconstrained quadratic optimization problem in the variable W 2 (ρ k ), but scheduled by parameter ρ k . In the next sections, it is proposed a theorem that symbolically solves [START_REF] Robert | Contribution à l'interaction commande/ordonnancement[END_REF] depending of the scheduling parameters. Thus a new polytopic/LMI formulation is studied to avoid symbolic computations.

Resolution by eigenvalue assignment

The following theorem and its associated proof gives one solution to problem P 1 .

Theorem 1 (See [START_REF] Ding | Model-based Fault Diagnosis Techniques[END_REF] for the proof.)

Given an optimization problem of the form :

γ * = min X X T AX X T BX ( 21
)
where A and B are symmetric matrices, the minimum γ corresponding to the criterion given in [START_REF] Simani | Model-based Fault Diagnosis in Dynamic Systems Using Identification Techniques[END_REF] is reached by X * such that :

X * = ϑ λq(A,B) (22)
where λ q (A, B) stands for the lowest generalized eigenvalue of the pair (A, B), and ϑ λq(A,B) its associated eigenvector. The minimum γ * is given by γ * = λ q (A, B).

Thanks to Theorem 1, problem P 1 (20) can be solved by :

P 1 : W 2 (ρ k ) T = ϑ λq(Γ 1 (ρ k ),Γ 2 (ρ k )) (ρ k ) (23)
Then, it is easy to recover the parity vector W (ρ k ) thanks to equation ( 12). This theorem clearly solves problem P 1 . It has to be pointed out that its resolution involves to compute generalized eigenvalues and eigenvectors, depending on the parameter ρ k . As each ρ i belongs in an infinite dimension set (ρ i ∈ ρ min ρ max ), the resolution of infinite dimension is impossible. On the other hand, in the case of smart and small dimension systems, where it has been considered few uncertainties, this computation can be handled symbolically. However, most of systems are complex, the resolution involves very hard computation and consequently hard implementation.

Facing this reality, this symbolic resolution has been given up making use of a polytopic approach. Then the optimization problem is rewritten in a new polytopic form, where each vertex represents constant sub-optimization problems. In this way, instead of considering the scheduling parameter within the resolution, computations are made at each vertex of the polytope, synthesizing as many parity vectors W i as polytope vertices. Thus the parity vector W (ρ k ) is built from the linear combination of each W i .

LMI optimization formulation

The problem P 1 can be rewritten as the problem P 2 [START_REF] Ding | Model-based Fault Diagnosis Techniques[END_REF]:

P 2 : γ 2 (ρ k ) = min W 2 W 2 (ρ k ) T Γ 1 (ρ k ) -κ 2 Γ 2 (ρ k ) W 2 (ρ k ) (24)
In effect, the aim is to find a vector W 2 (ρ k ) which minimizes the sensibility of uncertainties and disturbances -here represented by matrix Γ 1 (ρ k ) -and maximizes the effect of faults, represented by matrix Γ 2 (ρ k ).

Remark 3. The problems P 1 and P 2 are not strictly equals. They can be considered as strictly equals if κ is chosen as the lowest eigenvalue of the pair (Γ 1 ,Γ 2 ). However, in our case, κ is just chosen as an extra degree of freedom to fulfill the further constraints. Nevertheless, even if both problems are not strictly equals, they traduce the same objective : minimize the effect of the disturbances (Γ 1 ) and maximize the effect of the fault (Γ 2 ).

To better understand the process formulation, the problem is firstly addressed for LTI systems (section 4.4.1) and secondly for LPV systems (section 4.5).

Case of LTI systems

Consider the optimization problem for classical LTI matrices Γ i=1,2 . The aim of the problem is to find a vector W 2 s.t. :

γ = min W 2 W 2 T (Γ 1 -κ 2 Γ 2 ) Γκ W 2 (25)
It can be rewritten as a BMI problem : minimize

W 2 γ subject to W 2 T Γ κ W 2 ≺ γ (26)
which can be expressed as an LMI thanks to the Schur Lemma on equation ( 26) :

     minimize W 2 γ subject to Γ κ -1 W 2 W 2 T γ ≻ 0 ( 27
)
where Γ κ has to guarantee Γ κ ≻ 0.

Remark 4. The constraint Γ κ ≻ 0 has to be guaranteed due to the Schur Lemma. This condition is guaranteed by choosing properly the scalar κ. For the sequel, it is considered that κ is properly defined so the constraint is no more a part of the problem.

From the problem given in [START_REF] Yueyang | Parity space-based fault detection for linear time-varying systems with multiple packet dropouts[END_REF], a trivial solution consists in choosing W 2 as a null matrix. This solution is not allowable for our problem. So an additional constraint is added in order to tackle this problem :

W 2 = O 1×m•s (28)
This constraint cannot be directly implemented as an LMI since the vector W 2 is not a symmetric square matrix. As a consequence, it is considered a new diagonal matrix Y , defined by :

Y = diag(W 2 ) ( 29
)
which from it can be derived the following constraint :

trace(|Y |) ≻ ǫ ǫ > 0 (30)
Finally, the optimization problem can be rewritten in terms of LMI optimization as :

         minimize W 2 γ subject to    Γ κ -1 W 2 W 2 T γ ≻ 0 trace(|Y |) -ǫ ≻ 0 ǫ > 0 (31)
This LMI formulation allows to solve the problem P 2 for LTI matrices. The next section presents a way to extend the results to LPV systems.

Extension to LPV systems

Applying directly the results of the proposed approach for LPV systems is not allowable as it involves infinite LMI resolution among all the parameter set. However, the matrix Γ κ (ρ k ) (built from Γ 1 (ρ k ) and Γ 2 (ρ k )) can be rewritten in a polytopic form as

Γ κ (ρ k ) = q i=1 α i (ρ k )Γ ki ( 32
)
The aim of working in the polytopic framework relies in the fact that the study can be applied to each subsystems at each vertex of the polytope. However, by extension of (31), it has to be computed the inverse of the matrix Γ κ (ρ k ). So considering directly the polytopic formulation of the matrix Γ k (ρ k ) is not useful since it should not preserve the linearity in the parameters α i . Nevertheless, the interest relies in the polytopic formulation of its inverse Γ -1 k (ρ k ) which can be expressed as :

Γ -1 κ (ρ k ) = α 0 (ρ k ) r i=1 αi (ρ k ) Γ ri ( 33
)
where the term α 0 (k) stands for the inverse of the determinant of matrix Γ κ (ρ k ). Moreover, as the matrix Γ κ (ρ k ) has to be positive definite for all parameters ρ k , its associated determinant is also positive.

Remark 5. According to the polytopic formulation of the system, each αi are positive. So, positive definiteness of the product αi Γ ri is only affected by Γ ri .

The LMI optimization problem can be written as : minimize

W 2 γ subject to γ -W 2 T Γ κ (ρ k )W 2 ≻ 0 ( 34
)
where the constraint can be developed as :

γ -W 2 T Γ κ (ρ k )W 2 ≻ 0 ⇔ γ -W 2 T α 0 (ρ k ) r i=1 αi (ρ k ) Γ ri -1 W 2 ≻ 0 ⇔ γ - 1 α 0 (ρ k ) W 2 T r i=1 αi (ρ k ) Γ ri -1 W 2 ≻ 0 1 ⇔ γα 0 (ρ k ) γ ′ (ρ k ) -W 2 T r i=1 αi (ρ k ) Γ ri -1 W 2 ≻ 0 ⇔ γ ′ (ρ k ) -W 2 T r i=1 αi (ρ k ) Γ ri -1 W 2 ≻ 0 (35)
Applying the Schur complement on (35) yields the LMI constraint :

   r i=1 αi (ρ k ) Γ ri W 2 W 2 T γ ′    ≻ 0 (36)
Choosing the vector W 2 in the polytopic form :

W 2 = r i=1 αi (ρ k )W i (37)
and the same structure for γ ′ (ρ k ) allows to solve r LMIs :

r i=1 αi (ρ k ) Γ ri W 2i W 2 T i γ ′ ≻ 0 (38)
which is guaranteed by

Γ ri W 2i W 2 T i γ ′ ≻ 0 ∀i ∈ 1 : r (39)
Adapting equation ( 31) with the LPV constraint (39), the problem P 2 is obtained by the following optimization problem :

         minimize W 2 γ ′ subject to    Γ ri W 2i W 2 T i γ ′ ≻ 0 trace(|Y i |) -ǫ ≻ 0 ǫ > 0 ∀i ∈ 1 : r (40)
where each Y i are defined by extension of the LTI case as Y i = diag(X i ).

Remark 6. It this formulation, it has been omitted the fact that each matrices Γ ri -defining the polytopic formulation of the problem -has to be positive definite. In effect, the initial matrix Γ κ (ρ k ) has been constructed in order to be positive definite. However, nothing guarantees that each sub-matrices Γ ri are positive definite (as they can represent systems with no physical meaning), except for ones which really belong to the parameter definition.

Case of non positive definite matrices. In agreement with remark 6, some matrices written Γ - ri might not be positive definite, and can be decomposed via a singular value decomposition as :

Γ - ri = V n • D n1 > 0 O O D n2 < 0 Dn •V n T ( 41
)
where V n corresponds to the eigenvectors of Γ - ri and D n the matrix of its eigenvalues. Matrix D n1 represents the positive eigenvalues of matrix D n while D n2 the negative ones.

In order to avoid the problem of non positive definiteness, the sub-matrice D n2 is replaced by a matrix D + n2 with positive values, large enough in order not to affect the result of the optimization. In effect, it is known that the optimum rise to the lowest eigenvalue of the system (see Theorem 1).

Remark 7. The best solution is given by the eigenvector associated to the lowest eigenvalue of the inverse of Γ - ri . The eigenvalues D + n2 are said to be "large enough" in order not to affect the result of the optimization. Large enough refers to "at least larger than the other ones". In this case, the optimum reached by the optimization procedure will not be affected.

It is finally considered the matrix Γri instead of Γ - ri for the optimization process defined by : Γri

= V n • D n1 O O D + n2 Dn •V n T (42)
Let's just note that the transformation from Γ - ri to Γri does not restrict the problem solutions. It is just a way to avoid unavailable solutions.

Interest of small time varying parameters

In the past section, it has been highlight the interest of the polytopic formulation of the matrix Γ -1 k (ρ k ). The main drawbacks of such approach is that it leads to a more conservative solution set and foremost a large number of subsystems Γ ri , 2 N where N stands for the number of individual scheduling parameters defining the matrix Γ -1 κ (ρ k ). The following presents tricks to reduce the polytope size and so the complexity of the solution.

Taylor approximation

It is known the following equality as the Taylor development of a function f :

f (x) = +∞ n=0 f (n) (a) n! (x -a) n (43)
where f (n) denotes the n th derivative of function (43) at the point a.

According to this property, the expression of the scheduling parameters and their time shift can be expressed as :

ρ(k + τ ) = ρ(k) + τ • ρ ′ (k) ≤Mρ + +∞ n=2 ρ (n) (k) n! (τ ) n (44) ρ(k + τ ) ≃ ρ(k) + τ M ρ (45)
where M ρ represents the maximum variation of parameter ρ.

This simplification (if it can be assumed) is very useful as it allows to simplify the problem. If the scheduling parameters can be considered constant within the time horizon s, it will lead to a residual constructed with only the knowledge of ρ k instead of ρ k-s:k . Finally, the inner products of time shifts are only constructed with the knowledge of the scheduling parameter ρ k . Thanks to this simplification, the further polytope reduction can be adopted.

Polytope reduction

In the case of small time varying parameters, the scheduling parameters can be considered as constant within the time window defined by the horizon.

Thus, it will only remain in the matrix Γ -1 k the term ρ k and its powers in the form Γ

-1 κ (ρ k , ρ 2 k , • • • , ρ N k ).
The classical polytopic modeling will need to define P = 2 r vertices of the polytope.

However, the relation between each parameters is not taken into account. For instance, in the case of two scheduling parameters (as illustrated in figure 1), the vertex ω 4 = (ρ 1 , ρ2 ) is not required since the 3 other vertices are sufficient to characterize the parameter definition. This reductive approach can be generalized to polytopes of dimension N since the minimal value of the scheduling parameter is null (as presented in [START_REF] Robert | Contribution à l'interaction commande/ordonnancement[END_REF]) :

Property 1 A vertex ω j = (ν 1 , ν 2 , • • • , ν N ) -
where each coordinate ν i is defined as ν i = {ρ min = 0, ρ max } -is an admissible vertex if its coordinates verify the following property :

ν n+1 ≤ ρ max ν n (46)
Therefore, as a simplification, only N + 1 vertices are finally useful instead of 2 N .

Thanks to those presented tricks, the computations are simplified which allow for implementation on a real vehicle, as presented in the following section.

Application on a vehicle lateral dynamics system

The previous depicted theory has been applied on a vehicle lateral dynamics system. Some experimental data has been taken from a real vehicle "Renault Scenic" (figure 2 The aim of this applicative study is to detect a fault on a lateral acceleration sensor. The system under consideration is the whole lateral dynamics system illustrated in figure 3.

The modeling of the system rests on the bicycle model as presented in [START_REF] Poussot-Vassal | Commande robuste LPV multivariable de chassis automobile[END_REF][START_REF] Mammar | Vehicle handling improvement by active steering[END_REF][START_REF] Ackermann | Yaw disturbance attenuation by robust decoupling of car steering[END_REF], where the dynamics is given by : [START_REF] Tóth | Discretisation of linear parameter-varying state-space representations[END_REF], several discretization techniques for LPV state space models are available. Here the rectangular discretization is chosen as it provides a low computational load, and preserves the linearity in the parameters.

β(t) ṙ(t) = -c αV +c αH mv(t) l H c αH -l V c αV mv(t) 2 -1 l H c αH -l V c αV Iz l 2 V c αV +l 2 H c αH Izv(t) β(t) r(t) + c αV mv(t) l V c αV Iz u L (t) a y (t) r(t) = -c αV +c αH m l H c αH -l V c αV mv(t) 2 0 1 β(t) r(t) + c αV m 0 u L (t) (47)
The discrete matrices are given by :

A 0 (ρ(k)) = I n + T d A(ρ(kT d )) B 0 (ρ(k)) = T d B(ρ(kT d )) C 0 (ρ(k)) = C(ρ(kT d )) D 0 (ρ(k)) = D(ρ(kT d ))
where T d is the sampling period. Thus, the nominal discrete LPV matrices (as in ( 5)) corresponding to the state space model is given in (48) :

A 0 (ρ k ) = 1 -T d T d l H c αH -l V c αV Iz 1 + 1 v(kT d ) ρ 1k -T d c αV +c αH m 0 0 -T d l 2 v c αV +l 2 H c αH Iz + 1 v(kT d ) 2 ρ 2k 0 T d l H c αH -lvc αV m 0 0 (48a) B 0 (ρ k ) = 0 T d l V c αV Iz + ρ 1k T d c αV m 0 (48b) C 0 (ρ k ) = -c αV +c αH m 0 0 1 + ρ 1k 0 l H c αH -lvc αV m 0 0 (48c) D 0 (ρ k ) = c αV m 0 ( 48d
)
where there are 2 scheduling parameters ρ 1k = 1 v(kT d ) and ρ 2k = 1 v(kT d ) 2 . However, the dependency between parameters ρ 1 and ρ 2 is clear :

ρ 2 = ρ 1
2 . This relation is taken for further computations. Only one scheduling parameter ρ 1k is finally considered.

Note that those matrices A 0 (ρ k ), B 0 (ρ k ), C 0 (ρ k ) and D 0 (ρ k ) represent the nominal model of the system.

Data selection

MIPS laboratory provided data of the speed of the vehicle, steering wheel angle and lateral acceleration. The steering wheel angle and the vehicle longitudinal speed are respectively presented in figures 4a and 4b. A comparison between the data from MIPS and the corresponding bicycle model outputs are illustrated in figure 4c.

In can be observed that the bicycle model fits the real vehicle dynamics. However, some differences can be noticed especially due to the neglected dynamics, the modeling approximations and inaccurate parameters. This remark emphasis the uncertain characteristic of the method.

Fault detection by U -LPV parity space approach

The matrices A 1 , B d and D d has been designed as in (5) to complete the model which is not perfect. In effect, mostly the stiffness parameters c αV and c αH are not perfectly known. Consequently, the matrix A 1 is chosen as 20% of the nominal state matrix A 0 , by considering a constant mean speed of 75km.h -1 ≃ 20.83m.s -1 , so ρ * = 1 20.83 = 0.048.

A 1 = 0.2A 0 (ρ * ) = 0.2A 0 (0.048)

In addition, one uncertain input is considered with its distribution matrices B d and D d given by :

B d = 0.2B 0 (0.048) D d = 0 2.064
Those matrices allow to encompass the differences observed on figure 4. At this step, the system formulation has exactly the same structure than in (5).

The horizon s has been chosen as s = 3 in order to ensure a perfect decoupling face to the nominal system.

As the scheduling parameter ρ 1 is related to the longitudinal speed of the vehicle, it can be assumed as constant within the horizon of s = 3 samples (60 ms).

The matrix P (ρ k ) -which constitute the first step in the computation of the parity matrix -is built from equation [START_REF] Frank | Fault diagnosis in dynamic systems using analytical and knowledge-based redundancy : a survey and some new results[END_REF]. Then matrices Γ 1 (ρ k ) and Γ 2 (ρ k ) are constructed. It yields 6 products of the scheduling parameters ρ 1k in their definition.

The constant κ has been chosen as κ = 27 to guarantee the positive definiteness of the matrix Γ κ (ρ k ). Thus, the inverse matrix Γ -1 k (ρ k ) is computed. It results 14 products of the scheduling parameter ρ 1k .

At this step, for the sake of the polytopic modeling, it should be considered 2 14 = 16384 vertices of the polytope, which is technically not available. It has to be pointed out that in this applicative example, the scheduling parameter ρ 1k is always lower than 1 since the vehicle longitudinal speed is larger than 3.6 km.h -1 . As a first simplification, the terms ρ 1k

x lower than a certain threshold can be omitted. Moreover, thanks to the simplifications exposed in section 4.6.2, the necessary number of vertices is reduced to 6, which is far more easy to compute and to implement.

Finally, the LMI optimization process lead to the vector W 2 (ρ k ) constructed with 6 sub-vectors W 2i as :

W 2 (ρ k ) = 6 i=1 αi (ρ k )W 2i (49)

Faulty scenario

The data are performed in a healthy measuring system. As a consequence, the fault has been numerically added in simulation. The considered fault f (k) has been added from t = 150s to t = 158s to the first system output a y (k). Its amplitude is +0.5 m.s -2 .

Residuals

It has been compared both LPV and U -LPV approaches applied in this application. Both residuals r LP V and r LP V u , respectively representing the residual of the LPV and U -LPV approach are illustrated in figure 5. In this case, the comparison between different residuals has been done with normalized residuals, meaning the mean value of the residual during the faulty time is one.

In this approach, it can be shown that both approaches lead to effective fault detection. However, the LPV approach is quite sensitive to the unmodeled dynamics. In effect, it can be shown that after the fault, when the residual should be small, it remains some large amplitudes. As an information, the min/max ratio representing the minimum value in faulty case face the maximal value in healthy situation is computed : ̟ LP V = 1.39.

On the other hand, the U -LPV approach gives some better results. In effect, it can be shown that the effect of unmodeled dynamics has been attenuated. In effect, the min/max ratio is in this case ̟ LP V u = 4.04. This result emphasis the uncertain characteristic of the approach.

Conclusion

The problem which is considered in this paper is the design of residuals for Fault Detection on LPV systems and Uncertain LPV systems subject to Unknown Inputs. The objectives has been fulfilled by considering the classical parity-space based fault detection approach, but adressed for scheduled matrices. The resulting parity matrices are also parameters dependent. Thus, the uncertainty has been tackled by synthesizing a parity matrix via an LMI optimization which is sensitive to the fault and the least receptive to uncertainties nor disturbances.

The method has been successfully applied with experimental data coming from the MIPS laboratory on a vehicle "Renault Scenic". The final result compares the single LPV approach face to the U -LPV one. This second approach show the interest of considering uncertainties within the residual synthesis.

Figure 1 :

 1 Figure 1: Illustration of the polytope reduction

  ). Data have been provided by the French laboratory MIPS 2 (Modélisation, Intelligence, Processus et Systèmes), a partner in the framework of the French ANR project INOVE.

Figure 2 :

 2 Figure 2: Photo of the Renault Scenic used

Figure 3 :

 3 Figure 3: Illustration of the vehicle lateral dynamics

Figure 4 :

 4 Figure 4: Comparison between MIPS data and the bicycle model

Figure 5 : 8 .

 58 Figure 5: Comparison between LPV and U -LPV approaches

  This model represents the nominal behavior of the system.The numerical values and the description of the parameters are given in the following table :

	Variable Value	Unit	Comments
	g	9.80665	m.s -2	gravity acceleration constant
	m	1621	kg	vehicle total mass
	l V	1.15	m	distance from C.G. to front axle
	l H	1.38	m	distance from C.G. to rear axle
	I z	1975	kg.m 2	moment of inertia about the z-axis
	c αV	57117 N.rad -1	front axle tire cornering stiffness
	c αH	81396 N.rad -1	rear axle tire cornering stiffness
	v		m.s -1	vehicle longitudinal velocity
	β		rad	vehicle side slip angle
	ψ(t)		rad.s -1	vehicle raw rate
	a y		m.s -2	vehicle lateral acceleration
	u L		rad	vehicle steering angle
	As presented in

α 0 (ρ k ) = 0 as Γ κ (ρ k ) is positive definite

http://www.mips.uha.fr/

✩ This work is supported by the french national project INOVE / ANR BLAN 0308.